using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Runtime.Serialization;
using System.Collections;
using System.Data;
using System.ComponentModel;
using System.Data.OracleClient;
using WPFExcelReport.Helpers;
using WPFExcelReport.Controls;
namespace WPFExcelReport
{
   public partial class VWASTAMM
    {
      #region======ColumnSchema==========
       /*
                public string WAMANDANT { get { if (dwMaster == null) return ""; return dwMaster["WAMANDANT"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMANDANT"] = value; OnPropertyChanged("WAMANDANT", value); } } //lENGth 2
                public string WAKUNDNR { get { if (dwMaster == null) return ""; return dwMaster["WAKUNDNR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKUNDNR"] = value; OnPropertyChanged("WAKUNDNR", value); } } //lENGth 8
                public string WAWERK { get { if (dwMaster == null) return ""; return dwMaster["WAWERK"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAWERK"] = value; OnPropertyChanged("WAWERK", value); } } //lENGth 3
                public string WAABT { get { if (dwMaster == null) return ""; return dwMaster["WAABT"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAABT"] = value; OnPropertyChanged("WAABT", value); } } //lENGth 3
                public string WAART { get { if (dwMaster == null) return ""; return dwMaster["WAART"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAART"] = value; OnPropertyChanged("WAART", value); } } //lENGth 20
                public string WAVAR { get { if (dwMaster == null) return ""; return dwMaster["WAVAR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAVAR"] = value; OnPropertyChanged("WAVAR", value); } } //lENGth 2
                public double WAAENZL { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAAENZL"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAAENZL"] = value; OnPropertyChanged("WAAENZL", value); } } //lENGth 0
                public string WAAENB { get { if (dwMaster == null) return ""; return dwMaster["WAAENB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAAENB"] = value; OnPropertyChanged("WAAENB", value); } } //lENGth 8
                public double WAAEND { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAAEND"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAAEND"] = value; OnPropertyChanged("WAAEND", value); } } //lENGth 0
                public string WANEUB { get { if (dwMaster == null) return ""; return dwMaster["WANEUB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WANEUB"] = value; OnPropertyChanged("WANEUB", value); } } //lENGth 8
                public double WANEUD { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WANEUD"].ToString()); } set { if (dwMaster == null) return; dwMaster["WANEUD"] = value; OnPropertyChanged("WANEUD", value); } } //lENGth 0
                public string WABEZ { get { if (dwMaster == null) return ""; return dwMaster["WABEZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WABEZ"] = value; OnPropertyChanged("WABEZ", value); } } //lENGth 40
                public string WAMTART { get { if (dwMaster == null) return ""; return dwMaster["WAMTART"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMTART"] = value; OnPropertyChanged("WAMTART", value); } } //lENGth 4
                public string WAMU { get { if (dwMaster == null) return ""; return dwMaster["WAMU"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMU"] = value; OnPropertyChanged("WAMU", value); } } //lENGth 1
                public string WARKZ { get { if (dwMaster == null) return ""; return dwMaster["WARKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARKZ"] = value; OnPropertyChanged("WARKZ", value); } } //lENGth 1
                public string WAFKZ { get { if (dwMaster == null) return ""; return dwMaster["WAFKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFKZ"] = value; OnPropertyChanged("WAFKZ", value); } } //lENGth 1
                public string WAMUART { get { if (dwMaster == null) return ""; return dwMaster["WAMUART"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMUART"] = value; OnPropertyChanged("WAMUART", value); } } //lENGth 20
                public string WAMUNR { get { if (dwMaster == null) return ""; return dwMaster["WAMUNR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMUNR"] = value; OnPropertyChanged("WAMUNR", value); } } //lENGth 20
                public string WAHERLD { get { if (dwMaster == null) return ""; return dwMaster["WAHERLD"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAHERLD"] = value; OnPropertyChanged("WAHERLD", value); } } //lENGth 3
                public string WAFDDIM { get { if (dwMaster == null) return ""; return dwMaster["WAFDDIM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFDDIM"] = value; OnPropertyChanged("WAFDDIM", value); } } //lENGth 3
                public string WAMURLOD { get { if (dwMaster == null) return ""; return dwMaster["WAMURLOD"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMURLOD"] = value; OnPropertyChanged("WAMURLOD", value); } } //lENGth 2
                public string WAMUPROD { get { if (dwMaster == null) return ""; return dwMaster["WAMUPROD"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMUPROD"] = value; OnPropertyChanged("WAMUPROD", value); } } //lENGth 2
                public string WAMUCTOD { get { if (dwMaster == null) return ""; return dwMaster["WAMUCTOD"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMUCTOD"] = value; OnPropertyChanged("WAMUCTOD", value); } } //lENGth 1
                public double WAMUDTRL { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAMUDTRL"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAMUDTRL"] = value; OnPropertyChanged("WAMUDTRL", value); } } //lENGth 0
                public string WAMUBIRL { get { if (dwMaster == null) return ""; return dwMaster["WAMUBIRL"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMUBIRL"] = value; OnPropertyChanged("WAMUBIRL", value); } } //lENGth 8
                public string WAGASTA { get { if (dwMaster == null) return ""; return dwMaster["WAGASTA"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAGASTA"] = value; OnPropertyChanged("WAGASTA", value); } } //lENGth 1
                public string WAMASTA { get { if (dwMaster == null) return ""; return dwMaster["WAMASTA"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMASTA"] = value; OnPropertyChanged("WAMASTA", value); } } //lENGth 1
                public string WAKESTA { get { if (dwMaster == null) return ""; return dwMaster["WAKESTA"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKESTA"] = value; OnPropertyChanged("WAKESTA", value); } } //lENGth 1
                public string WAROSTA { get { if (dwMaster == null) return ""; return dwMaster["WAROSTA"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAROSTA"] = value; OnPropertyChanged("WAROSTA", value); } } //lENGth 1
                public string WARBSTA { get { if (dwMaster == null) return ""; return dwMaster["WARBSTA"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARBSTA"] = value; OnPropertyChanged("WARBSTA", value); } } //lENGth 1
                public string WAFBSTA { get { if (dwMaster == null) return ""; return dwMaster["WAFBSTA"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFBSTA"] = value; OnPropertyChanged("WAFBSTA", value); } } //lENGth 1
                public string WARPROF { get { if (dwMaster == null) return ""; return dwMaster["WARPROF"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARPROF"] = value; OnPropertyChanged("WARPROF", value); } } //lENGth 1
                public string WAFPROF { get { if (dwMaster == null) return ""; return dwMaster["WAFPROF"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFPROF"] = value; OnPropertyChanged("WAFPROF", value); } } //lENGth 1
                public string WARLSTA { get { if (dwMaster == null) return ""; return dwMaster["WARLSTA"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARLSTA"] = value; OnPropertyChanged("WARLSTA", value); } } //lENGth 1
                public string WAFLSTA { get { if (dwMaster == null) return ""; return dwMaster["WAFLSTA"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFLSTA"] = value; OnPropertyChanged("WAFLSTA", value); } } //lENGth 1
                public string WARSTAKZ { get { if (dwMaster == null) return ""; return dwMaster["WARSTAKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARSTAKZ"] = value; OnPropertyChanged("WARSTAKZ", value); } } //lENGth 1
                public string WAWAART { get { if (dwMaster == null) return ""; return dwMaster["WAWAART"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAWAART"] = value; OnPropertyChanged("WAWAART", value); } } //lENGth 3
                public string WARFERTKZ { get { if (dwMaster == null) return ""; return dwMaster["WARFERTKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARFERTKZ"] = value; OnPropertyChanged("WARFERTKZ", value); } } //lENGth 1
                public string WARKL { get { if (dwMaster == null) return ""; return dwMaster["WARKL"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARKL"] = value; OnPropertyChanged("WARKL", value); } } //lENGth 4
                public string WARMEHRB { get { if (dwMaster == null) return ""; return dwMaster["WARMEHRB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARMEHRB"] = value; OnPropertyChanged("WARMEHRB", value); } } //lENGth 1
                public string WARVOLL { get { if (dwMaster == null) return ""; return dwMaster["WARVOLL"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARVOLL"] = value; OnPropertyChanged("WARVOLL", value); } } //lENGth 1
                public string WARAUFM { get { if (dwMaster == null) return ""; return dwMaster["WARAUFM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARAUFM"] = value; OnPropertyChanged("WARAUFM", value); } } //lENGth 2
                public string WATRAUFM { get { if (dwMaster == null) return ""; return dwMaster["WATRAUFM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WATRAUFM"] = value; OnPropertyChanged("WATRAUFM", value); } } //lENGth 2
                public double WATRLG { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WATRLG"].ToString()); } set { if (dwMaster == null) return; dwMaster["WATRLG"] = value; OnPropertyChanged("WATRLG", value); } } //lENGth 0
                public double WARSTDLG { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARSTDLG"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARSTDLG"] = value; OnPropertyChanged("WARSTDLG", value); } } //lENGth 0
                public double WARSTDGW { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARSTDGW"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARSTDGW"] = value; OnPropertyChanged("WARSTDGW", value); } } //lENGth 0
                public string WARABLOM { get { if (dwMaster == null) return ""; return dwMaster["WARABLOM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARABLOM"] = value; OnPropertyChanged("WARABLOM", value); } } //lENGth 10
                public string WARMUNR { get { if (dwMaster == null) return ""; return dwMaster["WARMUNR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARMUNR"] = value; OnPropertyChanged("WARMUNR", value); } } //lENGth 15
                public string WARBEM { get { if (dwMaster == null) return ""; return dwMaster["WARBEM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARBEM"] = value; OnPropertyChanged("WARBEM", value); } } //lENGth 40
                public string WATEXTE1 { get { if (dwMaster == null) return ""; return dwMaster["WATEXTE1"].ToString(); } set { if (dwMaster == null) return; dwMaster["WATEXTE1"] = value; OnPropertyChanged("WATEXTE1", value); } } //lENGth 10
                public string WATEXTE2 { get { if (dwMaster == null) return ""; return dwMaster["WATEXTE2"].ToString(); } set { if (dwMaster == null) return; dwMaster["WATEXTE2"] = value; OnPropertyChanged("WATEXTE2", value); } } //lENGth 10
                public string WATEXTE3 { get { if (dwMaster == null) return ""; return dwMaster["WATEXTE3"].ToString(); } set { if (dwMaster == null) return; dwMaster["WATEXTE3"] = value; OnPropertyChanged("WATEXTE3", value); } } //lENGth 10
                public string WATEXTE4 { get { if (dwMaster == null) return ""; return dwMaster["WATEXTE4"].ToString(); } set { if (dwMaster == null) return; dwMaster["WATEXTE4"] = value; OnPropertyChanged("WATEXTE4", value); } } //lENGth 10
                public string WAKRITI { get { if (dwMaster == null) return ""; return dwMaster["WAKRITI"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKRITI"] = value; OnPropertyChanged("WAKRITI", value); } } //lENGth 1
                public string WARGKZ1 { get { if (dwMaster == null) return ""; return dwMaster["WARGKZ1"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARGKZ1"] = value; OnPropertyChanged("WARGKZ1", value); } } //lENGth 1
                public string WAGFKZ { get { if (dwMaster == null) return ""; return dwMaster["WAGFKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAGFKZ"] = value; OnPropertyChanged("WAGFKZ", value); } } //lENGth 1
                public string WARAUFT { get { if (dwMaster == null) return ""; return dwMaster["WARAUFT"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARAUFT"] = value; OnPropertyChanged("WARAUFT", value); } } //lENGth 8
                public double WARAUFD { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARAUFD"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARAUFD"] = value; OnPropertyChanged("WARAUFD", value); } } //lENGth 0
                public string WARUNGLFM { get { if (dwMaster == null) return ""; return dwMaster["WARUNGLFM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARUNGLFM"] = value; OnPropertyChanged("WARUNGLFM", value); } } //lENGth 1
                public string WARUNGQM { get { if (dwMaster == null) return ""; return dwMaster["WARUNGQM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARUNGQM"] = value; OnPropertyChanged("WARUNGQM", value); } } //lENGth 1
                public string WARUNBRT { get { if (dwMaster == null) return ""; return dwMaster["WARUNBRT"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARUNBRT"] = value; OnPropertyChanged("WARUNBRT", value); } } //lENGth 1
                public string WARUNFDK { get { if (dwMaster == null) return ""; return dwMaster["WARUNFDK"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARUNFDK"] = value; OnPropertyChanged("WARUNFDK", value); } } //lENGth 1
                public string WARUNFDS { get { if (dwMaster == null) return ""; return dwMaster["WARUNFDS"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARUNFDS"] = value; OnPropertyChanged("WARUNFDS", value); } } //lENGth 1
                public double WARWBRT { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARWBRT"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARWBRT"] = value; OnPropertyChanged("WARWBRT", value); } } //lENGth 0
                public double WARBRLST { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARBRLST"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARBRLST"] = value; OnPropertyChanged("WARBRLST", value); } } //lENGth 0
                public double WARBRTOL { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARBRTOL"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARBRTOL"] = value; OnPropertyChanged("WARBRTOL", value); } } //lENGth 0
                public double WARGRQM { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARGRQM"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARGRQM"] = value; OnPropertyChanged("WARGRQM", value); } } //lENGth 0
                public double WARGRLFD { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARGRLFD"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARGRLFD"] = value; OnPropertyChanged("WARGRLFD", value); } } //lENGth 0
                public double WARGWTOL { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARGWTOL"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARGWTOL"] = value; OnPropertyChanged("WARGWTOL", value); } } //lENGth 0
                public string WARARTDICKE { get { if (dwMaster == null) return ""; return dwMaster["WARARTDICKE"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARARTDICKE"] = value; OnPropertyChanged("WARARTDICKE", value); } } //lENGth 4
                public string WARARTTOLP { get { if (dwMaster == null) return ""; return dwMaster["WARARTTOLP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARARTTOLP"] = value; OnPropertyChanged("WARARTTOLP", value); } } //lENGth 4
                public string WARARTTOLM { get { if (dwMaster == null) return ""; return dwMaster["WARARTTOLM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARARTTOLM"] = value; OnPropertyChanged("WARARTTOLM", value); } } //lENGth 4
                public double WARFDDIK { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARFDDIK"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARFDDIK"] = value; OnPropertyChanged("WARFDDIK", value); } } //lENGth 0
                public double WARFDDIS { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARFDDIS"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARFDDIS"] = value; OnPropertyChanged("WARFDDIS", value); } } //lENGth 0
                public string WABIND { get { if (dwMaster == null) return ""; return dwMaster["WABIND"].ToString(); } set { if (dwMaster == null) return; dwMaster["WABIND"] = value; OnPropertyChanged("WABIND", value); } } //lENGth 15
                public double WARIPP { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARIPP"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARIPP"] = value; OnPropertyChanged("WARIPP", value); } } //lENGth 0
                public string WASCHLICHTGR { get { if (dwMaster == null) return ""; return dwMaster["WASCHLICHTGR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASCHLICHTGR"] = value; OnPropertyChanged("WASCHLICHTGR", value); } } //lENGth 5
                public string WASCHLICHTNR { get { if (dwMaster == null) return ""; return dwMaster["WASCHLICHTNR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASCHLICHTNR"] = value; OnPropertyChanged("WASCHLICHTNR", value); } } //lENGth 15
                public string WAEINZNR { get { if (dwMaster == null) return ""; return dwMaster["WAEINZNR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAEINZNR"] = value; OnPropertyChanged("WAEINZNR", value); } } //lENGth 15
                public double WATSDSCH { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WATSDSCH"].ToString()); } set { if (dwMaster == null) return; dwMaster["WATSDSCH"] = value; OnPropertyChanged("WATSDSCH", value); } } //lENGth 0
                public string WASTTEIL { get { if (dwMaster == null) return ""; return dwMaster["WASTTEIL"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASTTEIL"] = value; OnPropertyChanged("WASTTEIL", value); } } //lENGth 1
                public string WAFSTAKZ { get { if (dwMaster == null) return ""; return dwMaster["WAFSTAKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFSTAKZ"] = value; OnPropertyChanged("WAFSTAKZ", value); } } //lENGth 1
                public string WAFFERTKZ { get { if (dwMaster == null) return ""; return dwMaster["WAFFERTKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFFERTKZ"] = value; OnPropertyChanged("WAFFERTKZ", value); } } //lENGth 1
                public string WAAUSART { get { if (dwMaster == null) return ""; return dwMaster["WAAUSART"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAAUSART"] = value; OnPropertyChanged("WAAUSART", value); } } //lENGth 4
                public string WASTUEART { get { if (dwMaster == null) return ""; return dwMaster["WASTUEART"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASTUEART"] = value; OnPropertyChanged("WASTUEART", value); } } //lENGth 3
                public string WAVWART { get { if (dwMaster == null) return ""; return dwMaster["WAVWART"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAVWART"] = value; OnPropertyChanged("WAVWART", value); } } //lENGth 20
                public string WAVWVAR { get { if (dwMaster == null) return ""; return dwMaster["WAVWVAR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAVWVAR"] = value; OnPropertyChanged("WAVWVAR", value); } } //lENGth 2
                public string WAVARFR { get { if (dwMaster == null) return ""; return dwMaster["WAVARFR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAVARFR"] = value; OnPropertyChanged("WAVARFR", value); } } //lENGth 1
                public string WAFMEHRB { get { if (dwMaster == null) return ""; return dwMaster["WAFMEHRB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFMEHRB"] = value; OnPropertyChanged("WAFMEHRB", value); } } //lENGth 1
                public string WAFVOLL { get { if (dwMaster == null) return ""; return dwMaster["WAFVOLL"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFVOLL"] = value; OnPropertyChanged("WAFVOLL", value); } } //lENGth 1
                public string WAFAUFM { get { if (dwMaster == null) return ""; return dwMaster["WAFAUFM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFAUFM"] = value; OnPropertyChanged("WAFAUFM", value); } } //lENGth 2
                public double WAFSTDLG { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFSTDLG"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFSTDLG"] = value; OnPropertyChanged("WAFSTDLG", value); } } //lENGth 0
                public double WAFSTDGW { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFSTDGW"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFSTDGW"] = value; OnPropertyChanged("WAFSTDGW", value); } } //lENGth 0
                public string WAFABLOM { get { if (dwMaster == null) return ""; return dwMaster["WAFABLOM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFABLOM"] = value; OnPropertyChanged("WAFABLOM", value); } } //lENGth 10
                public string WAGVORL { get { if (dwMaster == null) return ""; return dwMaster["WAGVORL"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAGVORL"] = value; OnPropertyChanged("WAGVORL", value); } } //lENGth 10
                public string WAOVORL { get { if (dwMaster == null) return ""; return dwMaster["WAOVORL"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAOVORL"] = value; OnPropertyChanged("WAOVORL", value); } } //lENGth 10
                public string WAFRBST { get { if (dwMaster == null) return ""; return dwMaster["WAFRBST"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFRBST"] = value; OnPropertyChanged("WAFRBST", value); } } //lENGth 2
                public string WALAMFR { get { if (dwMaster == null) return ""; return dwMaster["WALAMFR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WALAMFR"] = value; OnPropertyChanged("WALAMFR", value); } } //lENGth 1
                public string WAFGKZ1 { get { if (dwMaster == null) return ""; return dwMaster["WAFGKZ1"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFGKZ1"] = value; OnPropertyChanged("WAFGKZ1", value); } } //lENGth 1
                public string WAFGKZ2 { get { if (dwMaster == null) return ""; return dwMaster["WAFGKZ2"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFGKZ2"] = value; OnPropertyChanged("WAFGKZ2", value); } } //lENGth 1
                public string WAFGKZ3 { get { if (dwMaster == null) return ""; return dwMaster["WAFGKZ3"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFGKZ3"] = value; OnPropertyChanged("WAFGKZ3", value); } } //lENGth 1
                public string WASCHLKZ { get { if (dwMaster == null) return ""; return dwMaster["WASCHLKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASCHLKZ"] = value; OnPropertyChanged("WASCHLKZ", value); } } //lENGth 1
                public string WAFAUFT { get { if (dwMaster == null) return ""; return dwMaster["WAFAUFT"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFAUFT"] = value; OnPropertyChanged("WAFAUFT", value); } } //lENGth 8
                public double WAFAUFD { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFAUFD"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFAUFD"] = value; OnPropertyChanged("WAFAUFD", value); } } //lENGth 0
                public string WAFKART { get { if (dwMaster == null) return ""; return dwMaster["WAFKART"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFKART"] = value; OnPropertyChanged("WAFKART", value); } } //lENGth 10
                public string WAKOLL { get { if (dwMaster == null) return ""; return dwMaster["WAKOLL"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKOLL"] = value; OnPropertyChanged("WAKOLL", value); } } //lENGth 5
                public string WAFBEM { get { if (dwMaster == null) return ""; return dwMaster["WAFBEM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFBEM"] = value; OnPropertyChanged("WAFBEM", value); } } //lENGth 40
                public string WAFUNGLFM { get { if (dwMaster == null) return ""; return dwMaster["WAFUNGLFM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFUNGLFM"] = value; OnPropertyChanged("WAFUNGLFM", value); } } //lENGth 1
                public string WAFUNGQM { get { if (dwMaster == null) return ""; return dwMaster["WAFUNGQM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFUNGQM"] = value; OnPropertyChanged("WAFUNGQM", value); } } //lENGth 1
                public string WAFUNBRT { get { if (dwMaster == null) return ""; return dwMaster["WAFUNBRT"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFUNBRT"] = value; OnPropertyChanged("WAFUNBRT", value); } } //lENGth 1
                public string WAFUNFDK { get { if (dwMaster == null) return ""; return dwMaster["WAFUNFDK"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFUNFDK"] = value; OnPropertyChanged("WAFUNFDK", value); } } //lENGth 1
                public string WAFUNFDS { get { if (dwMaster == null) return ""; return dwMaster["WAFUNFDS"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFUNFDS"] = value; OnPropertyChanged("WAFUNFDS", value); } } //lENGth 1
                public double WAFBRTU { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFBRTU"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFBRTU"] = value; OnPropertyChanged("WAFBRTU", value); } } //lENGth 0
                public double WAFBRTUT { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFBRTUT"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFBRTUT"] = value; OnPropertyChanged("WAFBRTUT", value); } } //lENGth 0
                public double WAFBRTL { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFBRTL"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFBRTL"] = value; OnPropertyChanged("WAFBRTL", value); } } //lENGth 0
                public double WAFBRTLT { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFBRTLT"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFBRTLT"] = value; OnPropertyChanged("WAFBRTLT", value); } } //lENGth 0
                public double WASCHNK { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WASCHNK"].ToString()); } set { if (dwMaster == null) return; dwMaster["WASCHNK"] = value; OnPropertyChanged("WASCHNK", value); } } //lENGth 0
                public double WALAEAEND { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WALAEAEND"].ToString()); } set { if (dwMaster == null) return; dwMaster["WALAEAEND"] = value; OnPropertyChanged("WALAEAEND", value); } } //lENGth 0
                public double WARENDEM { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARENDEM"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARENDEM"] = value; OnPropertyChanged("WARENDEM", value); } } //lENGth 0
                public double WARENDEMNT { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARENDEMNT"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARENDEMNT"] = value; OnPropertyChanged("WARENDEMNT", value); } } //lENGth 0
                public double WAGWVERL { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAGWVERL"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAGWVERL"] = value; OnPropertyChanged("WAGWVERL", value); } } //lENGth 0
                public string WAALKV { get { if (dwMaster == null) return ""; return dwMaster["WAALKV"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAALKV"] = value; OnPropertyChanged("WAALKV", value); } } //lENGth 2
                public double WAFGRQM { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFGRQM"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFGRQM"] = value; OnPropertyChanged("WAFGRQM", value); } } //lENGth 0
                public double WAFGRLFD { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFGRLFD"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFGRLFD"] = value; OnPropertyChanged("WAFGRLFD", value); } } //lENGth 0
                public double WAFGWTOL { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFGWTOL"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFGWTOL"] = value; OnPropertyChanged("WAFGWTOL", value); } } //lENGth 0
                public string WAFARTDICKE { get { if (dwMaster == null) return ""; return dwMaster["WAFARTDICKE"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFARTDICKE"] = value; OnPropertyChanged("WAFARTDICKE", value); } } //lENGth 4
                public string WAFARTTOLP { get { if (dwMaster == null) return ""; return dwMaster["WAFARTTOLP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFARTTOLP"] = value; OnPropertyChanged("WAFARTTOLP", value); } } //lENGth 4
                public string WAFARTTOLM { get { if (dwMaster == null) return ""; return dwMaster["WAFARTTOLM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFARTTOLM"] = value; OnPropertyChanged("WAFARTTOLM", value); } } //lENGth 4
                public double WAFFDDIK { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFFDDIK"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFFDDIK"] = value; OnPropertyChanged("WAFFDDIK", value); } } //lENGth 0
                public double WAFFDDIS { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFFDDIS"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFFDDIS"] = value; OnPropertyChanged("WAFFDDIS", value); } } //lENGth 0
                public string WAUNI { get { if (dwMaster == null) return ""; return dwMaster["WAUNI"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAUNI"] = value; OnPropertyChanged("WAUNI", value); } } //lENGth 1
                public string WACOLORKZ { get { if (dwMaster == null) return ""; return dwMaster["WACOLORKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WACOLORKZ"] = value; OnPropertyChanged("WACOLORKZ", value); } } //lENGth 1
                public string WAUNIGA { get { if (dwMaster == null) return ""; return dwMaster["WAUNIGA"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAUNIGA"] = value; OnPropertyChanged("WAUNIGA", value); } } //lENGth 1
                public double WAGEWICHT2 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAGEWICHT2"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAGEWICHT2"] = value; OnPropertyChanged("WAGEWICHT2", value); } } //lENGth 0
                public string WAFVERF1 { get { if (dwMaster == null) return ""; return dwMaster["WAFVERF1"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFVERF1"] = value; OnPropertyChanged("WAFVERF1", value); } } //lENGth 3
                public string WAFVERF2 { get { if (dwMaster == null) return ""; return dwMaster["WAFVERF2"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFVERF2"] = value; OnPropertyChanged("WAFVERF2", value); } } //lENGth 3
                public string WAFVERF3 { get { if (dwMaster == null) return ""; return dwMaster["WAFVERF3"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFVERF3"] = value; OnPropertyChanged("WAFVERF3", value); } } //lENGth 3
                public string WAFVERF4 { get { if (dwMaster == null) return ""; return dwMaster["WAFVERF4"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFVERF4"] = value; OnPropertyChanged("WAFVERF4", value); } } //lENGth 3
                public string WAFZUSTAND1 { get { if (dwMaster == null) return ""; return dwMaster["WAFZUSTAND1"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFZUSTAND1"] = value; OnPropertyChanged("WAFZUSTAND1", value); } } //lENGth 4
                public string WAFZUSTAND2 { get { if (dwMaster == null) return ""; return dwMaster["WAFZUSTAND2"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFZUSTAND2"] = value; OnPropertyChanged("WAFZUSTAND2", value); } } //lENGth 4
                public string WAFZUSTAND3 { get { if (dwMaster == null) return ""; return dwMaster["WAFZUSTAND3"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFZUSTAND3"] = value; OnPropertyChanged("WAFZUSTAND3", value); } } //lENGth 4
                public string WAFZUSTAND4 { get { if (dwMaster == null) return ""; return dwMaster["WAFZUSTAND4"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFZUSTAND4"] = value; OnPropertyChanged("WAFZUSTAND4", value); } } //lENGth 4
                public string WAFVERFN1 { get { if (dwMaster == null) return ""; return dwMaster["WAFVERFN1"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFVERFN1"] = value; OnPropertyChanged("WAFVERFN1", value); } } //lENGth 3
                public string WAFVERFN2 { get { if (dwMaster == null) return ""; return dwMaster["WAFVERFN2"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFVERFN2"] = value; OnPropertyChanged("WAFVERFN2", value); } } //lENGth 3
                public string WAFVERFN3 { get { if (dwMaster == null) return ""; return dwMaster["WAFVERFN3"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFVERFN3"] = value; OnPropertyChanged("WAFVERFN3", value); } } //lENGth 3
                public string WAFVERFN4 { get { if (dwMaster == null) return ""; return dwMaster["WAFVERFN4"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFVERFN4"] = value; OnPropertyChanged("WAFVERFN4", value); } } //lENGth 3
                public string WAFFGRPN1 { get { if (dwMaster == null) return ""; return dwMaster["WAFFGRPN1"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFFGRPN1"] = value; OnPropertyChanged("WAFFGRPN1", value); } } //lENGth 1
                public string WAFFGRPN2 { get { if (dwMaster == null) return ""; return dwMaster["WAFFGRPN2"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFFGRPN2"] = value; OnPropertyChanged("WAFFGRPN2", value); } } //lENGth 1
                public string WAFFGRPN3 { get { if (dwMaster == null) return ""; return dwMaster["WAFFGRPN3"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFFGRPN3"] = value; OnPropertyChanged("WAFFGRPN3", value); } } //lENGth 1
                public string WAFFGRPN4 { get { if (dwMaster == null) return ""; return dwMaster["WAFFGRPN4"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFFGRPN4"] = value; OnPropertyChanged("WAFFGRPN4", value); } } //lENGth 1
                public string WAVNRKZ { get { if (dwMaster == null) return ""; return dwMaster["WAVNRKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAVNRKZ"] = value; OnPropertyChanged("WAVNRKZ", value); } } //lENGth 1
                public string WAZUSTKZ { get { if (dwMaster == null) return ""; return dwMaster["WAZUSTKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAZUSTKZ"] = value; OnPropertyChanged("WAZUSTKZ", value); } } //lENGth 1
                public string WAUEKLOKZ { get { if (dwMaster == null) return ""; return dwMaster["WAUEKLOKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAUEKLOKZ"] = value; OnPropertyChanged("WAUEKLOKZ", value); } } //lENGth 1
                public string WAFSUBST { get { if (dwMaster == null) return ""; return dwMaster["WAFSUBST"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFSUBST"] = value; OnPropertyChanged("WAFSUBST", value); } } //lENGth 15
                public double WAMAXFA { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAMAXFA"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAMAXFA"] = value; OnPropertyChanged("WAMAXFA", value); } } //lENGth 0
                public double WAAKZWG { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAAKZWG"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAAKZWG"] = value; OnPropertyChanged("WAAKZWG", value); } } //lENGth 0
                public double WAFRESTF { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFRESTF"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFRESTF"] = value; OnPropertyChanged("WAFRESTF", value); } } //lENGth 0
                public string WADRUCKBAR { get { if (dwMaster == null) return ""; return dwMaster["WADRUCKBAR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADRUCKBAR"] = value; OnPropertyChanged("WADRUCKBAR", value); } } //lENGth 1
                public double WAVBRGQM { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAVBRGQM"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAVBRGQM"] = value; OnPropertyChanged("WAVBRGQM", value); } } //lENGth 0
                public double WALEDR { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WALEDR"].ToString()); } set { if (dwMaster == null) return; dwMaster["WALEDR"] = value; OnPropertyChanged("WALEDR", value); } } //lENGth 0
                public string WADVERF1 { get { if (dwMaster == null) return ""; return dwMaster["WADVERF1"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADVERF1"] = value; OnPropertyChanged("WADVERF1", value); } } //lENGth 3
                public string WADVERF2 { get { if (dwMaster == null) return ""; return dwMaster["WADVERF2"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADVERF2"] = value; OnPropertyChanged("WADVERF2", value); } } //lENGth 3
                public string WADVERF3 { get { if (dwMaster == null) return ""; return dwMaster["WADVERF3"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADVERF3"] = value; OnPropertyChanged("WADVERF3", value); } } //lENGth 3
                public string WADVERF4 { get { if (dwMaster == null) return ""; return dwMaster["WADVERF4"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADVERF4"] = value; OnPropertyChanged("WADVERF4", value); } } //lENGth 3
                public string WADZUSTAND1 { get { if (dwMaster == null) return ""; return dwMaster["WADZUSTAND1"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADZUSTAND1"] = value; OnPropertyChanged("WADZUSTAND1", value); } } //lENGth 4
                public string WADZUSTAND2 { get { if (dwMaster == null) return ""; return dwMaster["WADZUSTAND2"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADZUSTAND2"] = value; OnPropertyChanged("WADZUSTAND2", value); } } //lENGth 4
                public string WADZUSTAND3 { get { if (dwMaster == null) return ""; return dwMaster["WADZUSTAND3"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADZUSTAND3"] = value; OnPropertyChanged("WADZUSTAND3", value); } } //lENGth 4
                public string WADZUSTAND4 { get { if (dwMaster == null) return ""; return dwMaster["WADZUSTAND4"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADZUSTAND4"] = value; OnPropertyChanged("WADZUSTAND4", value); } } //lENGth 4
                public string WADVERFN1 { get { if (dwMaster == null) return ""; return dwMaster["WADVERFN1"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADVERFN1"] = value; OnPropertyChanged("WADVERFN1", value); } } //lENGth 3
                public string WADVERFN2 { get { if (dwMaster == null) return ""; return dwMaster["WADVERFN2"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADVERFN2"] = value; OnPropertyChanged("WADVERFN2", value); } } //lENGth 3
                public string WADVERFN3 { get { if (dwMaster == null) return ""; return dwMaster["WADVERFN3"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADVERFN3"] = value; OnPropertyChanged("WADVERFN3", value); } } //lENGth 3
                public string WADVERFN4 { get { if (dwMaster == null) return ""; return dwMaster["WADVERFN4"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADVERFN4"] = value; OnPropertyChanged("WADVERFN4", value); } } //lENGth 3
                public string WADFGRPN1 { get { if (dwMaster == null) return ""; return dwMaster["WADFGRPN1"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADFGRPN1"] = value; OnPropertyChanged("WADFGRPN1", value); } } //lENGth 1
                public string WADFGRPN2 { get { if (dwMaster == null) return ""; return dwMaster["WADFGRPN2"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADFGRPN2"] = value; OnPropertyChanged("WADFGRPN2", value); } } //lENGth 1
                public string WADFGRPN3 { get { if (dwMaster == null) return ""; return dwMaster["WADFGRPN3"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADFGRPN3"] = value; OnPropertyChanged("WADFGRPN3", value); } } //lENGth 1
                public string WADFGRPN4 { get { if (dwMaster == null) return ""; return dwMaster["WADFGRPN4"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADFGRPN4"] = value; OnPropertyChanged("WADFGRPN4", value); } } //lENGth 1
                public string WADSUBST { get { if (dwMaster == null) return ""; return dwMaster["WADSUBST"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADSUBST"] = value; OnPropertyChanged("WADSUBST", value); } } //lENGth 15
                public double WADRESTF { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WADRESTF"].ToString()); } set { if (dwMaster == null) return; dwMaster["WADRESTF"] = value; OnPropertyChanged("WADRESTF", value); } } //lENGth 0
                public double WAFAKTOR { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFAKTOR"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFAKTOR"] = value; OnPropertyChanged("WAFAKTOR", value); } } //lENGth 0
                public string WABSUBST { get { if (dwMaster == null) return ""; return dwMaster["WABSUBST"].ToString(); } set { if (dwMaster == null) return; dwMaster["WABSUBST"] = value; OnPropertyChanged("WABSUBST", value); } } //lENGth 15
                public string WAVORBWA { get { if (dwMaster == null) return ""; return dwMaster["WAVORBWA"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAVORBWA"] = value; OnPropertyChanged("WAVORBWA", value); } } //lENGth 3
                public string WANACHBWA { get { if (dwMaster == null) return ""; return dwMaster["WANACHBWA"].ToString(); } set { if (dwMaster == null) return; dwMaster["WANACHBWA"] = value; OnPropertyChanged("WANACHBWA", value); } } //lENGth 3
                public string WAVORBFB { get { if (dwMaster == null) return ""; return dwMaster["WAVORBFB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAVORBFB"] = value; OnPropertyChanged("WAVORBFB", value); } } //lENGth 3
                public string WANACHBFB { get { if (dwMaster == null) return ""; return dwMaster["WANACHBFB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WANACHBFB"] = value; OnPropertyChanged("WANACHBFB", value); } } //lENGth 3
                public string WAVORBDR { get { if (dwMaster == null) return ""; return dwMaster["WAVORBDR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAVORBDR"] = value; OnPropertyChanged("WAVORBDR", value); } } //lENGth 3
                public string WANACHBDR { get { if (dwMaster == null) return ""; return dwMaster["WANACHBDR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WANACHBDR"] = value; OnPropertyChanged("WANACHBDR", value); } } //lENGth 3
                public string WAVORBAP { get { if (dwMaster == null) return ""; return dwMaster["WAVORBAP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAVORBAP"] = value; OnPropertyChanged("WAVORBAP", value); } } //lENGth 3
                public string WANACHBAP { get { if (dwMaster == null) return ""; return dwMaster["WANACHBAP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WANACHBAP"] = value; OnPropertyChanged("WANACHBAP", value); } } //lENGth 3
                public string WAMVB { get { if (dwMaster == null) return ""; return dwMaster["WAMVB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMVB"] = value; OnPropertyChanged("WAMVB", value); } } //lENGth 3
                public string WAMNB { get { if (dwMaster == null) return ""; return dwMaster["WAMNB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMNB"] = value; OnPropertyChanged("WAMNB", value); } } //lENGth 3
                public string WACVB { get { if (dwMaster == null) return ""; return dwMaster["WACVB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WACVB"] = value; OnPropertyChanged("WACVB", value); } } //lENGth 3
                public string WACNB { get { if (dwMaster == null) return ""; return dwMaster["WACNB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WACNB"] = value; OnPropertyChanged("WACNB", value); } } //lENGth 3
                public string WABVB { get { if (dwMaster == null) return ""; return dwMaster["WABVB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WABVB"] = value; OnPropertyChanged("WABVB", value); } } //lENGth 3
                public string WABNB { get { if (dwMaster == null) return ""; return dwMaster["WABNB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WABNB"] = value; OnPropertyChanged("WABNB", value); } } //lENGth 3
                public string WASVB { get { if (dwMaster == null) return ""; return dwMaster["WASVB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASVB"] = value; OnPropertyChanged("WASVB", value); } } //lENGth 3
                public string WASNB { get { if (dwMaster == null) return ""; return dwMaster["WASNB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASNB"] = value; OnPropertyChanged("WASNB", value); } } //lENGth 3
                public string WASUBSTGR { get { if (dwMaster == null) return ""; return dwMaster["WASUBSTGR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASUBSTGR"] = value; OnPropertyChanged("WASUBSTGR", value); } } //lENGth 3
                public string WAHANDICAP { get { if (dwMaster == null) return ""; return dwMaster["WAHANDICAP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAHANDICAP"] = value; OnPropertyChanged("WAHANDICAP", value); } } //lENGth 3
                public double WAZUSCHAB { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAZUSCHAB"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAZUSCHAB"] = value; OnPropertyChanged("WAZUSCHAB", value); } } //lENGth 0
                public double WALOSGRFB { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WALOSGRFB"].ToString()); } set { if (dwMaster == null) return; dwMaster["WALOSGRFB"] = value; OnPropertyChanged("WALOSGRFB", value); } } //lENGth 0
                public string WAQCCHECK { get { if (dwMaster == null) return ""; return dwMaster["WAQCCHECK"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAQCCHECK"] = value; OnPropertyChanged("WAQCCHECK", value); } } //lENGth 1
                public string WADART { get { if (dwMaster == null) return ""; return dwMaster["WADART"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADART"] = value; OnPropertyChanged("WADART", value); } } //lENGth 20
                public string WADVAR { get { if (dwMaster == null) return ""; return dwMaster["WADVAR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADVAR"] = value; OnPropertyChanged("WADVAR", value); } } //lENGth 2
                public string WADSTDKZ { get { if (dwMaster == null) return ""; return dwMaster["WADSTDKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADSTDKZ"] = value; OnPropertyChanged("WADSTDKZ", value); } } //lENGth 1
                public string WADSACHB { get { if (dwMaster == null) return ""; return dwMaster["WADSACHB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADSACHB"] = value; OnPropertyChanged("WADSACHB", value); } } //lENGth 8
                public string WASCHNKZ { get { if (dwMaster == null) return ""; return dwMaster["WASCHNKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASCHNKZ"] = value; OnPropertyChanged("WASCHNKZ", value); } } //lENGth 1
                public string WAPROGRP { get { if (dwMaster == null) return ""; return dwMaster["WAPROGRP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAPROGRP"] = value; OnPropertyChanged("WAPROGRP", value); } } //lENGth 3
                public string WAARTGRP { get { if (dwMaster == null) return ""; return dwMaster["WAARTGRP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAARTGRP"] = value; OnPropertyChanged("WAARTGRP", value); } } //lENGth 3
                public string WAWBZEIT { get { if (dwMaster == null) return ""; return dwMaster["WAWBZEIT"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAWBZEIT"] = value; OnPropertyChanged("WAWBZEIT", value); } } //lENGth 2
                public double WAMINBST { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAMINBST"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAMINBST"] = value; OnPropertyChanged("WAMINBST", value); } } //lENGth 0
                public double WAMAXBST { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAMAXBST"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAMAXBST"] = value; OnPropertyChanged("WAMAXBST", value); } } //lENGth 0
                public double WAOPTMGR { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAOPTMGR"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAOPTMGR"] = value; OnPropertyChanged("WAOPTMGR", value); } } //lENGth 0
                public double WAOPTMGF { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAOPTMGF"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAOPTMGF"] = value; OnPropertyChanged("WAOPTMGF", value); } } //lENGth 0
                public double WARMINPMENG { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARMINPMENG"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARMINPMENG"] = value; OnPropertyChanged("WARMINPMENG", value); } } //lENGth 0
                public double WAFMINPMENG { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFMINPMENG"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFMINPMENG"] = value; OnPropertyChanged("WAFMINPMENG", value); } } //lENGth 0
                public string WAUEBM { get { if (dwMaster == null) return ""; return dwMaster["WAUEBM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAUEBM"] = value; OnPropertyChanged("WAUEBM", value); } } //lENGth 3
                public string WAUEBG { get { if (dwMaster == null) return ""; return dwMaster["WAUEBG"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAUEBG"] = value; OnPropertyChanged("WAUEBG", value); } } //lENGth 1
                public string WAUEBF { get { if (dwMaster == null) return ""; return dwMaster["WAUEBF"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAUEBF"] = value; OnPropertyChanged("WAUEBF", value); } } //lENGth 12
                public string WAMATPRF { get { if (dwMaster == null) return ""; return dwMaster["WAMATPRF"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMATPRF"] = value; OnPropertyChanged("WAMATPRF", value); } } //lENGth 1
                public string WABRTPRF { get { if (dwMaster == null) return ""; return dwMaster["WABRTPRF"].ToString(); } set { if (dwMaster == null) return; dwMaster["WABRTPRF"] = value; OnPropertyChanged("WABRTPRF", value); } } //lENGth 1
                public string WAGQMPRF { get { if (dwMaster == null) return ""; return dwMaster["WAGQMPRF"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAGQMPRF"] = value; OnPropertyChanged("WAGQMPRF", value); } } //lENGth 1
                public string WASTKGP { get { if (dwMaster == null) return ""; return dwMaster["WASTKGP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASTKGP"] = value; OnPropertyChanged("WASTKGP", value); } } //lENGth 1
                public string WASCHLIP { get { if (dwMaster == null) return ""; return dwMaster["WASCHLIP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASCHLIP"] = value; OnPropertyChanged("WASCHLIP", value); } } //lENGth 1
                public string WASCHLIA { get { if (dwMaster == null) return ""; return dwMaster["WASCHLIA"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASCHLIA"] = value; OnPropertyChanged("WASCHLIA", value); } } //lENGth 1
                public string WALPABR { get { if (dwMaster == null) return ""; return dwMaster["WALPABR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WALPABR"] = value; OnPropertyChanged("WALPABR", value); } } //lENGth 1
                public string WADISPZS { get { if (dwMaster == null) return ""; return dwMaster["WADISPZS"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADISPZS"] = value; OnPropertyChanged("WADISPZS", value); } } //lENGth 1
                public string WADRPAR { get { if (dwMaster == null) return ""; return dwMaster["WADRPAR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WADRPAR"] = value; OnPropertyChanged("WADRPAR", value); } } //lENGth 5
                public string WAZUSTR { get { if (dwMaster == null) return ""; return dwMaster["WAZUSTR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAZUSTR"] = value; OnPropertyChanged("WAZUSTR", value); } } //lENGth 1
                public string WAWDSUM { get { if (dwMaster == null) return ""; return dwMaster["WAWDSUM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAWDSUM"] = value; OnPropertyChanged("WAWDSUM", value); } } //lENGth 1
                public string WASTSKZ { get { if (dwMaster == null) return ""; return dwMaster["WASTSKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASTSKZ"] = value; OnPropertyChanged("WASTSKZ", value); } } //lENGth 1
                public string WASTSART { get { if (dwMaster == null) return ""; return dwMaster["WASTSART"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASTSART"] = value; OnPropertyChanged("WASTSART", value); } } //lENGth 1
                public string WASTSAUF { get { if (dwMaster == null) return ""; return dwMaster["WASTSAUF"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASTSAUF"] = value; OnPropertyChanged("WASTSAUF", value); } } //lENGth 1
                public string WASTSLG { get { if (dwMaster == null) return ""; return dwMaster["WASTSLG"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASTSLG"] = value; OnPropertyChanged("WASTSLG", value); } } //lENGth 1
                public string WASTSDKZ { get { if (dwMaster == null) return ""; return dwMaster["WASTSDKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WASTSDKZ"] = value; OnPropertyChanged("WASTSDKZ", value); } } //lENGth 1
                public string WAFILLER1 { get { if (dwMaster == null) return ""; return dwMaster["WAFILLER1"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFILLER1"] = value; OnPropertyChanged("WAFILLER1", value); } } //lENGth 10
                public double WAVOLU { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAVOLU"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAVOLU"] = value; OnPropertyChanged("WAVOLU", value); } } //lENGth 0
                public string WAVOLAM { get { if (dwMaster == null) return ""; return dwMaster["WAVOLAM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAVOLAM"] = value; OnPropertyChanged("WAVOLAM", value); } } //lENGth 2
                public double WAVOLDIAM { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAVOLDIAM"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAVOLDIAM"] = value; OnPropertyChanged("WAVOLDIAM", value); } } //lENGth 0
                public double WAVOLMTR { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAVOLMTR"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAVOLMTR"] = value; OnPropertyChanged("WAVOLMTR", value); } } //lENGth 0
                public double WAVOLAMVOL { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAVOLAMVOL"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAVOLAMVOL"] = value; OnPropertyChanged("WAVOLAMVOL", value); } } //lENGth 0
                public double WAANAB { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAANAB"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAANAB"] = value; OnPropertyChanged("WAANAB", value); } } //lENGth 0
                public double WAALBIS { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAALBIS"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAALBIS"] = value; OnPropertyChanged("WAALBIS", value); } } //lENGth 0
                public string WAPLGRP { get { if (dwMaster == null) return ""; return dwMaster["WAPLGRP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAPLGRP"] = value; OnPropertyChanged("WAPLGRP", value); } } //lENGth 2
                public string WAPRODH { get { if (dwMaster == null) return ""; return dwMaster["WAPRODH"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAPRODH"] = value; OnPropertyChanged("WAPRODH", value); } } //lENGth 18
                public string WAMATKL { get { if (dwMaster == null) return ""; return dwMaster["WAMATKL"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMATKL"] = value; OnPropertyChanged("WAMATKL", value); } } //lENGth 9
                public string WAPMGRP { get { if (dwMaster == null) return ""; return dwMaster["WAPMGRP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAPMGRP"] = value; OnPropertyChanged("WAPMGRP", value); } } //lENGth 4
                public string WAPRFSCHL { get { if (dwMaster == null) return ""; return dwMaster["WAPRFSCHL"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAPRFSCHL"] = value; OnPropertyChanged("WAPRFSCHL", value); } } //lENGth 9
                public string WAKAART { get { if (dwMaster == null) return ""; return dwMaster["WAKAART"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKAART"] = value; OnPropertyChanged("WAKAART", value); } } //lENGth 20
                public string WAKAVAR { get { if (dwMaster == null) return ""; return dwMaster["WAKAVAR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKAVAR"] = value; OnPropertyChanged("WAKAVAR", value); } } //lENGth 2
                public string WAKASTD { get { if (dwMaster == null) return ""; return dwMaster["WAKASTD"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKASTD"] = value; OnPropertyChanged("WAKASTD", value); } } //lENGth 1
                public string WAKAZGRP { get { if (dwMaster == null) return ""; return dwMaster["WAKAZGRP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKAZGRP"] = value; OnPropertyChanged("WAKAZGRP", value); } } //lENGth 3
                public string WAKAPRGRPN1 { get { if (dwMaster == null) return ""; return dwMaster["WAKAPRGRPN1"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKAPRGRPN1"] = value; OnPropertyChanged("WAKAPRGRPN1", value); } } //lENGth 1
                public string WAKAPRGRPN2 { get { if (dwMaster == null) return ""; return dwMaster["WAKAPRGRPN2"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKAPRGRPN2"] = value; OnPropertyChanged("WAKAPRGRPN2", value); } } //lENGth 1
                public string WAKAPRGRPN3 { get { if (dwMaster == null) return ""; return dwMaster["WAKAPRGRPN3"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKAPRGRPN3"] = value; OnPropertyChanged("WAKAPRGRPN3", value); } } //lENGth 1
                public string WAKAAGRA { get { if (dwMaster == null) return ""; return dwMaster["WAKAAGRA"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKAAGRA"] = value; OnPropertyChanged("WAKAAGRA", value); } } //lENGth 5
                public string WAKAAGRP { get { if (dwMaster == null) return ""; return dwMaster["WAKAAGRP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKAAGRP"] = value; OnPropertyChanged("WAKAAGRP", value); } } //lENGth 2
                public double WAZWTWAHL { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAZWTWAHL"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAZWTWAHL"] = value; OnPropertyChanged("WAZWTWAHL", value); } } //lENGth 0
                public double WAVERL { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAVERL"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAVERL"] = value; OnPropertyChanged("WAVERL", value); } } //lENGth 0
                public double WAABR { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAABR"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAABR"] = value; OnPropertyChanged("WAABR", value); } } //lENGth 0
                public string WAABRTOL { get { if (dwMaster == null) return ""; return dwMaster["WAABRTOL"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAABRTOL"] = value; OnPropertyChanged("WAABRTOL", value); } } //lENGth 1
                public double WAKABRT { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAKABRT"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAKABRT"] = value; OnPropertyChanged("WAKABRT", value); } } //lENGth 0
                public double WARKABRTOL { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WARKABRTOL"].ToString()); } set { if (dwMaster == null) return; dwMaster["WARKABRTOL"] = value; OnPropertyChanged("WARKABRTOL", value); } } //lENGth 0
                public double WAFKABRTOL { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFKABRTOL"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFKABRTOL"] = value; OnPropertyChanged("WAFKABRTOL", value); } } //lENGth 0
                public string WAMATKTO { get { if (dwMaster == null) return ""; return dwMaster["WAMATKTO"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMATKTO"] = value; OnPropertyChanged("WAMATKTO", value); } } //lENGth 6
                public string WAKTO1 { get { if (dwMaster == null) return ""; return dwMaster["WAKTO1"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKTO1"] = value; OnPropertyChanged("WAKTO1", value); } } //lENGth 6
                public string WAGV { get { if (dwMaster == null) return ""; return dwMaster["WAGV"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAGV"] = value; OnPropertyChanged("WAGV", value); } } //lENGth 6
                public double WAKBON { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAKBON"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAKBON"] = value; OnPropertyChanged("WAKBON", value); } } //lENGth 0
                public string WAMGKMM { get { if (dwMaster == null) return ""; return dwMaster["WAMGKMM"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMGKMM"] = value; OnPropertyChanged("WAMGKMM", value); } } //lENGth 8
                public double WAMEZ { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAMEZ"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAMEZ"] = value; OnPropertyChanged("WAMEZ", value); } } //lENGth 0
                public double WAWAG { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAWAG"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAWAG"] = value; OnPropertyChanged("WAWAG", value); } } //lENGth 0
                public string WABKLAS { get { if (dwMaster == null) return ""; return dwMaster["WABKLAS"].ToString(); } set { if (dwMaster == null) return; dwMaster["WABKLAS"] = value; OnPropertyChanged("WABKLAS", value); } } //lENGth 4
                public string WABWPLAN { get { if (dwMaster == null) return ""; return dwMaster["WABWPLAN"].ToString(); } set { if (dwMaster == null) return; dwMaster["WABWPLAN"] = value; OnPropertyChanged("WABWPLAN", value); } } //lENGth 1
                public string WAEKGRP { get { if (dwMaster == null) return ""; return dwMaster["WAEKGRP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAEKGRP"] = value; OnPropertyChanged("WAEKGRP", value); } } //lENGth 3
                public string WABSTME { get { if (dwMaster == null) return ""; return dwMaster["WABSTME"].ToString(); } set { if (dwMaster == null) return; dwMaster["WABSTME"] = value; OnPropertyChanged("WABSTME", value); } } //lENGth 3
                public string WAVABME { get { if (dwMaster == null) return ""; return dwMaster["WAVABME"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAVABME"] = value; OnPropertyChanged("WAVABME", value); } } //lENGth 1
                public string WAEKWSL { get { if (dwMaster == null) return ""; return dwMaster["WAEKWSL"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAEKWSL"] = value; OnPropertyChanged("WAEKWSL", value); } } //lENGth 4
                public string WALIEFNR { get { if (dwMaster == null) return ""; return dwMaster["WALIEFNR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WALIEFNR"] = value; OnPropertyChanged("WALIEFNR", value); } } //lENGth 8
                public string WAEG { get { if (dwMaster == null) return ""; return dwMaster["WAEG"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAEG"] = value; OnPropertyChanged("WAEG", value); } } //lENGth 1
                public string WABON { get { if (dwMaster == null) return ""; return dwMaster["WABON"].ToString(); } set { if (dwMaster == null) return; dwMaster["WABON"] = value; OnPropertyChanged("WABON", value); } } //lENGth 1
                public string WAKUNDE { get { if (dwMaster == null) return ""; return dwMaster["WAKUNDE"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKUNDE"] = value; OnPropertyChanged("WAKUNDE", value); } } //lENGth 8
                public string WALOHNW { get { if (dwMaster == null) return ""; return dwMaster["WALOHNW"].ToString(); } set { if (dwMaster == null) return; dwMaster["WALOHNW"] = value; OnPropertyChanged("WALOHNW", value); } } //lENGth 20
                public string WALOHNA { get { if (dwMaster == null) return ""; return dwMaster["WALOHNA"].ToString(); } set { if (dwMaster == null) return; dwMaster["WALOHNA"] = value; OnPropertyChanged("WALOHNA", value); } } //lENGth 20
                public double WASCHLIAUF { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WASCHLIAUF"].ToString()); } set { if (dwMaster == null) return; dwMaster["WASCHLIAUF"] = value; OnPropertyChanged("WASCHLIAUF", value); } } //lENGth 0
                public string WAPFCODE { get { if (dwMaster == null) return ""; return dwMaster["WAPFCODE"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAPFCODE"] = value; OnPropertyChanged("WAPFCODE", value); } } //lENGth 5
                public string WAAUFKZ { get { if (dwMaster == null) return ""; return dwMaster["WAAUFKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAAUFKZ"] = value; OnPropertyChanged("WAAUFKZ", value); } } //lENGth 1
                public string WAMRKM1 { get { if (dwMaster == null) return ""; return dwMaster["WAMRKM1"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMRKM1"] = value; OnPropertyChanged("WAMRKM1", value); } } //lENGth 4
                public string WAMRKM2 { get { if (dwMaster == null) return ""; return dwMaster["WAMRKM2"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMRKM2"] = value; OnPropertyChanged("WAMRKM2", value); } } //lENGth 4
                public string WAMRKM3 { get { if (dwMaster == null) return ""; return dwMaster["WAMRKM3"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMRKM3"] = value; OnPropertyChanged("WAMRKM3", value); } } //lENGth 4
                public string WAMRKM4 { get { if (dwMaster == null) return ""; return dwMaster["WAMRKM4"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMRKM4"] = value; OnPropertyChanged("WAMRKM4", value); } } //lENGth 4
                public string WAMRKM5 { get { if (dwMaster == null) return ""; return dwMaster["WAMRKM5"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAMRKM5"] = value; OnPropertyChanged("WAMRKM5", value); } } //lENGth 4
                public string WAESACHB { get { if (dwMaster == null) return ""; return dwMaster["WAESACHB"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAESACHB"] = value; OnPropertyChanged("WAESACHB", value); } } //lENGth 8
                public string WAESACHBKZ { get { if (dwMaster == null) return ""; return dwMaster["WAESACHBKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAESACHBKZ"] = value; OnPropertyChanged("WAESACHBKZ", value); } } //lENGth 1
                public double WAFBGRLFM { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFBGRLFM"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFBGRLFM"] = value; OnPropertyChanged("WAFBGRLFM", value); } } //lENGth 0
                public string WAPRUEFKZ { get { if (dwMaster == null) return ""; return dwMaster["WAPRUEFKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAPRUEFKZ"] = value; OnPropertyChanged("WAPRUEFKZ", value); } } //lENGth 1
                public string WAPRUEFBEN { get { if (dwMaster == null) return ""; return dwMaster["WAPRUEFBEN"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAPRUEFBEN"] = value; OnPropertyChanged("WAPRUEFBEN", value); } } //lENGth 8
                public double WAPRUEFDAT { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAPRUEFDAT"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAPRUEFDAT"] = value; OnPropertyChanged("WAPRUEFDAT", value); } } //lENGth 0
                public string WARAVGRP { get { if (dwMaster == null) return ""; return dwMaster["WARAVGRP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WARAVGRP"] = value; OnPropertyChanged("WARAVGRP", value); } } //lENGth 4
                public string WATAX { get { if (dwMaster == null) return ""; return dwMaster["WATAX"].ToString(); } set { if (dwMaster == null) return; dwMaster["WATAX"] = value; OnPropertyChanged("WATAX", value); } } //lENGth 3
                public string WAPARTBA { get { if (dwMaster == null) return ""; return dwMaster["WAPARTBA"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAPARTBA"] = value; OnPropertyChanged("WAPARTBA", value); } } //lENGth 1
                public double WAFDDIF { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["WAFDDIF"].ToString()); } set { if (dwMaster == null) return; dwMaster["WAFDDIF"] = value; OnPropertyChanged("WAFDDIF", value); } } //lENGth 0
                public string WAINSPCOR { get { if (dwMaster == null) return ""; return dwMaster["WAINSPCOR"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAINSPCOR"] = value; OnPropertyChanged("WAINSPCOR", value); } } //lENGth 4
                public string WAINSPGRP { get { if (dwMaster == null) return ""; return dwMaster["WAINSPGRP"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAINSPGRP"] = value; OnPropertyChanged("WAINSPGRP", value); } } //lENGth 4
                public string WAKENNFD { get { if (dwMaster == null) return ""; return dwMaster["WAKENNFD"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKENNFD"] = value; OnPropertyChanged("WAKENNFD", value); } } //lENGth 1
                public string WAFILLER2 { get { if (dwMaster == null) return ""; return dwMaster["WAFILLER2"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAFILLER2"] = value; OnPropertyChanged("WAFILLER2", value); } } //lENGth 31
       */
       #endregion
    } 
       public partial class UIWASTAMM
    {
      
        #region======ColumnSchema==========
       /*
       #region ==WAMANDANT===========
        public static readonly DependencyProperty WAMANDANTProperty = DependencyProperty.Register("WAMANDANT",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMANDANTChanged));
        public string WAMANDANT
        {
            get
            {
                return (string)GetValue(WAMANDANTProperty);
            }
            set
            {
                SetValue(WAMANDANTProperty, value);
                OnWAMANDANTChg();
            }
        }
        private static void OnWAMANDANTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMANDANT = (string)e.NewValue;
            }
        }
        public virtual void OnWAMANDANTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMANDANT=WAMANDANT;
        }
         #endregion
       #region ==WAKUNDNR===========
        public static readonly DependencyProperty WAKUNDNRProperty = DependencyProperty.Register("WAKUNDNR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKUNDNRChanged));
        public string WAKUNDNR
        {
            get
            {
                return (string)GetValue(WAKUNDNRProperty);
            }
            set
            {
                SetValue(WAKUNDNRProperty, value);
                OnWAKUNDNRChg();
            }
        }
        private static void OnWAKUNDNRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKUNDNR = (string)e.NewValue;
            }
        }
        public virtual void OnWAKUNDNRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKUNDNR=WAKUNDNR;
        }
         #endregion
       #region ==WAWERK===========
        public static readonly DependencyProperty WAWERKProperty = DependencyProperty.Register("WAWERK",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAWERKChanged));
        public string WAWERK
        {
            get
            {
                return (string)GetValue(WAWERKProperty);
            }
            set
            {
                SetValue(WAWERKProperty, value);
                OnWAWERKChg();
            }
        }
        private static void OnWAWERKChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAWERK = (string)e.NewValue;
            }
        }
        public virtual void OnWAWERKChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAWERK=WAWERK;
        }
         #endregion
       #region ==WAABT===========
        public static readonly DependencyProperty WAABTProperty = DependencyProperty.Register("WAABT",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAABTChanged));
        public string WAABT
        {
            get
            {
                return (string)GetValue(WAABTProperty);
            }
            set
            {
                SetValue(WAABTProperty, value);
                OnWAABTChg();
            }
        }
        private static void OnWAABTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAABT = (string)e.NewValue;
            }
        }
        public virtual void OnWAABTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAABT=WAABT;
        }
         #endregion
       #region ==WAART===========
        public static readonly DependencyProperty WAARTProperty = DependencyProperty.Register("WAART",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAARTChanged));
        public string WAART
        {
            get
            {
                return (string)GetValue(WAARTProperty);
            }
            set
            {
                SetValue(WAARTProperty, value);
                OnWAARTChg();
            }
        }
        private static void OnWAARTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAART = (string)e.NewValue;
            }
        }
        public virtual void OnWAARTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAART=WAART;
        }
         #endregion
       #region ==WAVAR===========
        public static readonly DependencyProperty WAVARProperty = DependencyProperty.Register("WAVAR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVARChanged));
        public string WAVAR
        {
            get
            {
                return (string)GetValue(WAVARProperty);
            }
            set
            {
                SetValue(WAVARProperty, value);
                OnWAVARChg();
            }
        }
        private static void OnWAVARChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVAR = (string)e.NewValue;
            }
        }
        public virtual void OnWAVARChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVAR=WAVAR;
        }
         #endregion
       #region ==WAAENZL===========
        public static readonly DependencyProperty WAAENZLProperty = DependencyProperty.Register("WAAENZL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAAENZLChanged));
        public string WAAENZL
        {
            get
            {
                return (string)GetValue(WAAENZLProperty);
            }
            set
            {
                SetValue(WAAENZLProperty, value);
                OnWAAENZLChg();
            }
        }
        private static void OnWAAENZLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAAENZL = (string)e.NewValue;
            }
        }
        public virtual void OnWAAENZLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAAENZL=WAAENZL;
        }
         #endregion
       #region ==WAAENB===========
        public static readonly DependencyProperty WAAENBProperty = DependencyProperty.Register("WAAENB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAAENBChanged));
        public string WAAENB
        {
            get
            {
                return (string)GetValue(WAAENBProperty);
            }
            set
            {
                SetValue(WAAENBProperty, value);
                OnWAAENBChg();
            }
        }
        private static void OnWAAENBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAAENB = (string)e.NewValue;
            }
        }
        public virtual void OnWAAENBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAAENB=WAAENB;
        }
         #endregion
       #region ==WAAEND===========
        public static readonly DependencyProperty WAAENDProperty = DependencyProperty.Register("WAAEND",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAAENDChanged));
        public string WAAEND
        {
            get
            {
                return (string)GetValue(WAAENDProperty);
            }
            set
            {
                SetValue(WAAENDProperty, value);
                OnWAAENDChg();
            }
        }
        private static void OnWAAENDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAAEND = (string)e.NewValue;
            }
        }
        public virtual void OnWAAENDChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAAEND=WAAEND;
        }
         #endregion
       #region ==WANEUB===========
        public static readonly DependencyProperty WANEUBProperty = DependencyProperty.Register("WANEUB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWANEUBChanged));
        public string WANEUB
        {
            get
            {
                return (string)GetValue(WANEUBProperty);
            }
            set
            {
                SetValue(WANEUBProperty, value);
                OnWANEUBChg();
            }
        }
        private static void OnWANEUBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WANEUB = (string)e.NewValue;
            }
        }
        public virtual void OnWANEUBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WANEUB=WANEUB;
        }
         #endregion
       #region ==WANEUD===========
        public static readonly DependencyProperty WANEUDProperty = DependencyProperty.Register("WANEUD",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWANEUDChanged));
        public string WANEUD
        {
            get
            {
                return (string)GetValue(WANEUDProperty);
            }
            set
            {
                SetValue(WANEUDProperty, value);
                OnWANEUDChg();
            }
        }
        private static void OnWANEUDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WANEUD = (string)e.NewValue;
            }
        }
        public virtual void OnWANEUDChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WANEUD=WANEUD;
        }
         #endregion
       #region ==WABEZ===========
        public static readonly DependencyProperty WABEZProperty = DependencyProperty.Register("WABEZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWABEZChanged));
        public string WABEZ
        {
            get
            {
                return (string)GetValue(WABEZProperty);
            }
            set
            {
                SetValue(WABEZProperty, value);
                OnWABEZChg();
            }
        }
        private static void OnWABEZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WABEZ = (string)e.NewValue;
            }
        }
        public virtual void OnWABEZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WABEZ=WABEZ;
        }
         #endregion
       #region ==WAMTART===========
        public static readonly DependencyProperty WAMTARTProperty = DependencyProperty.Register("WAMTART",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMTARTChanged));
        public string WAMTART
        {
            get
            {
                return (string)GetValue(WAMTARTProperty);
            }
            set
            {
                SetValue(WAMTARTProperty, value);
                OnWAMTARTChg();
            }
        }
        private static void OnWAMTARTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMTART = (string)e.NewValue;
            }
        }
        public virtual void OnWAMTARTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMTART=WAMTART;
        }
         #endregion
       #region ==WAMU===========
        public static readonly DependencyProperty WAMUProperty = DependencyProperty.Register("WAMU",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMUChanged));
        public string WAMU
        {
            get
            {
                return (string)GetValue(WAMUProperty);
            }
            set
            {
                SetValue(WAMUProperty, value);
                OnWAMUChg();
            }
        }
        private static void OnWAMUChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMU = (string)e.NewValue;
            }
        }
        public virtual void OnWAMUChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMU=WAMU;
        }
         #endregion
       #region ==WARKZ===========
        public static readonly DependencyProperty WARKZProperty = DependencyProperty.Register("WARKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARKZChanged));
        public string WARKZ
        {
            get
            {
                return (string)GetValue(WARKZProperty);
            }
            set
            {
                SetValue(WARKZProperty, value);
                OnWARKZChg();
            }
        }
        private static void OnWARKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWARKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARKZ=WARKZ;
        }
         #endregion
       #region ==WAFKZ===========
        public static readonly DependencyProperty WAFKZProperty = DependencyProperty.Register("WAFKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFKZChanged));
        public string WAFKZ
        {
            get
            {
                return (string)GetValue(WAFKZProperty);
            }
            set
            {
                SetValue(WAFKZProperty, value);
                OnWAFKZChg();
            }
        }
        private static void OnWAFKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWAFKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFKZ=WAFKZ;
        }
         #endregion
       #region ==WAMUART===========
        public static readonly DependencyProperty WAMUARTProperty = DependencyProperty.Register("WAMUART",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMUARTChanged));
        public string WAMUART
        {
            get
            {
                return (string)GetValue(WAMUARTProperty);
            }
            set
            {
                SetValue(WAMUARTProperty, value);
                OnWAMUARTChg();
            }
        }
        private static void OnWAMUARTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMUART = (string)e.NewValue;
            }
        }
        public virtual void OnWAMUARTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMUART=WAMUART;
        }
         #endregion
       #region ==WAMUNR===========
        public static readonly DependencyProperty WAMUNRProperty = DependencyProperty.Register("WAMUNR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMUNRChanged));
        public string WAMUNR
        {
            get
            {
                return (string)GetValue(WAMUNRProperty);
            }
            set
            {
                SetValue(WAMUNRProperty, value);
                OnWAMUNRChg();
            }
        }
        private static void OnWAMUNRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMUNR = (string)e.NewValue;
            }
        }
        public virtual void OnWAMUNRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMUNR=WAMUNR;
        }
         #endregion
       #region ==WAHERLD===========
        public static readonly DependencyProperty WAHERLDProperty = DependencyProperty.Register("WAHERLD",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAHERLDChanged));
        public string WAHERLD
        {
            get
            {
                return (string)GetValue(WAHERLDProperty);
            }
            set
            {
                SetValue(WAHERLDProperty, value);
                OnWAHERLDChg();
            }
        }
        private static void OnWAHERLDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAHERLD = (string)e.NewValue;
            }
        }
        public virtual void OnWAHERLDChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAHERLD=WAHERLD;
        }
         #endregion
       #region ==WAFDDIM===========
        public static readonly DependencyProperty WAFDDIMProperty = DependencyProperty.Register("WAFDDIM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFDDIMChanged));
        public string WAFDDIM
        {
            get
            {
                return (string)GetValue(WAFDDIMProperty);
            }
            set
            {
                SetValue(WAFDDIMProperty, value);
                OnWAFDDIMChg();
            }
        }
        private static void OnWAFDDIMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFDDIM = (string)e.NewValue;
            }
        }
        public virtual void OnWAFDDIMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFDDIM=WAFDDIM;
        }
         #endregion
       #region ==WAMURLOD===========
        public static readonly DependencyProperty WAMURLODProperty = DependencyProperty.Register("WAMURLOD",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMURLODChanged));
        public string WAMURLOD
        {
            get
            {
                return (string)GetValue(WAMURLODProperty);
            }
            set
            {
                SetValue(WAMURLODProperty, value);
                OnWAMURLODChg();
            }
        }
        private static void OnWAMURLODChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMURLOD = (string)e.NewValue;
            }
        }
        public virtual void OnWAMURLODChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMURLOD=WAMURLOD;
        }
         #endregion
       #region ==WAMUPROD===========
        public static readonly DependencyProperty WAMUPRODProperty = DependencyProperty.Register("WAMUPROD",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMUPRODChanged));
        public string WAMUPROD
        {
            get
            {
                return (string)GetValue(WAMUPRODProperty);
            }
            set
            {
                SetValue(WAMUPRODProperty, value);
                OnWAMUPRODChg();
            }
        }
        private static void OnWAMUPRODChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMUPROD = (string)e.NewValue;
            }
        }
        public virtual void OnWAMUPRODChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMUPROD=WAMUPROD;
        }
         #endregion
       #region ==WAMUCTOD===========
        public static readonly DependencyProperty WAMUCTODProperty = DependencyProperty.Register("WAMUCTOD",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMUCTODChanged));
        public string WAMUCTOD
        {
            get
            {
                return (string)GetValue(WAMUCTODProperty);
            }
            set
            {
                SetValue(WAMUCTODProperty, value);
                OnWAMUCTODChg();
            }
        }
        private static void OnWAMUCTODChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMUCTOD = (string)e.NewValue;
            }
        }
        public virtual void OnWAMUCTODChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMUCTOD=WAMUCTOD;
        }
         #endregion
       #region ==WAMUDTRL===========
        public static readonly DependencyProperty WAMUDTRLProperty = DependencyProperty.Register("WAMUDTRL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMUDTRLChanged));
        public string WAMUDTRL
        {
            get
            {
                return (string)GetValue(WAMUDTRLProperty);
            }
            set
            {
                SetValue(WAMUDTRLProperty, value);
                OnWAMUDTRLChg();
            }
        }
        private static void OnWAMUDTRLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMUDTRL = (string)e.NewValue;
            }
        }
        public virtual void OnWAMUDTRLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMUDTRL=WAMUDTRL;
        }
         #endregion
       #region ==WAMUBIRL===========
        public static readonly DependencyProperty WAMUBIRLProperty = DependencyProperty.Register("WAMUBIRL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMUBIRLChanged));
        public string WAMUBIRL
        {
            get
            {
                return (string)GetValue(WAMUBIRLProperty);
            }
            set
            {
                SetValue(WAMUBIRLProperty, value);
                OnWAMUBIRLChg();
            }
        }
        private static void OnWAMUBIRLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMUBIRL = (string)e.NewValue;
            }
        }
        public virtual void OnWAMUBIRLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMUBIRL=WAMUBIRL;
        }
         #endregion
       #region ==WAGASTA===========
        public static readonly DependencyProperty WAGASTAProperty = DependencyProperty.Register("WAGASTA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAGASTAChanged));
        public string WAGASTA
        {
            get
            {
                return (string)GetValue(WAGASTAProperty);
            }
            set
            {
                SetValue(WAGASTAProperty, value);
                OnWAGASTAChg();
            }
        }
        private static void OnWAGASTAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAGASTA = (string)e.NewValue;
            }
        }
        public virtual void OnWAGASTAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAGASTA=WAGASTA;
        }
         #endregion
       #region ==WAMASTA===========
        public static readonly DependencyProperty WAMASTAProperty = DependencyProperty.Register("WAMASTA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMASTAChanged));
        public string WAMASTA
        {
            get
            {
                return (string)GetValue(WAMASTAProperty);
            }
            set
            {
                SetValue(WAMASTAProperty, value);
                OnWAMASTAChg();
            }
        }
        private static void OnWAMASTAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMASTA = (string)e.NewValue;
            }
        }
        public virtual void OnWAMASTAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMASTA=WAMASTA;
        }
         #endregion
       #region ==WAKESTA===========
        public static readonly DependencyProperty WAKESTAProperty = DependencyProperty.Register("WAKESTA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKESTAChanged));
        public string WAKESTA
        {
            get
            {
                return (string)GetValue(WAKESTAProperty);
            }
            set
            {
                SetValue(WAKESTAProperty, value);
                OnWAKESTAChg();
            }
        }
        private static void OnWAKESTAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKESTA = (string)e.NewValue;
            }
        }
        public virtual void OnWAKESTAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKESTA=WAKESTA;
        }
         #endregion
       #region ==WAROSTA===========
        public static readonly DependencyProperty WAROSTAProperty = DependencyProperty.Register("WAROSTA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAROSTAChanged));
        public string WAROSTA
        {
            get
            {
                return (string)GetValue(WAROSTAProperty);
            }
            set
            {
                SetValue(WAROSTAProperty, value);
                OnWAROSTAChg();
            }
        }
        private static void OnWAROSTAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAROSTA = (string)e.NewValue;
            }
        }
        public virtual void OnWAROSTAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAROSTA=WAROSTA;
        }
         #endregion
       #region ==WARBSTA===========
        public static readonly DependencyProperty WARBSTAProperty = DependencyProperty.Register("WARBSTA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARBSTAChanged));
        public string WARBSTA
        {
            get
            {
                return (string)GetValue(WARBSTAProperty);
            }
            set
            {
                SetValue(WARBSTAProperty, value);
                OnWARBSTAChg();
            }
        }
        private static void OnWARBSTAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARBSTA = (string)e.NewValue;
            }
        }
        public virtual void OnWARBSTAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARBSTA=WARBSTA;
        }
         #endregion
       #region ==WAFBSTA===========
        public static readonly DependencyProperty WAFBSTAProperty = DependencyProperty.Register("WAFBSTA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFBSTAChanged));
        public string WAFBSTA
        {
            get
            {
                return (string)GetValue(WAFBSTAProperty);
            }
            set
            {
                SetValue(WAFBSTAProperty, value);
                OnWAFBSTAChg();
            }
        }
        private static void OnWAFBSTAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFBSTA = (string)e.NewValue;
            }
        }
        public virtual void OnWAFBSTAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFBSTA=WAFBSTA;
        }
         #endregion
       #region ==WARPROF===========
        public static readonly DependencyProperty WARPROFProperty = DependencyProperty.Register("WARPROF",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARPROFChanged));
        public string WARPROF
        {
            get
            {
                return (string)GetValue(WARPROFProperty);
            }
            set
            {
                SetValue(WARPROFProperty, value);
                OnWARPROFChg();
            }
        }
        private static void OnWARPROFChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARPROF = (string)e.NewValue;
            }
        }
        public virtual void OnWARPROFChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARPROF=WARPROF;
        }
         #endregion
       #region ==WAFPROF===========
        public static readonly DependencyProperty WAFPROFProperty = DependencyProperty.Register("WAFPROF",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFPROFChanged));
        public string WAFPROF
        {
            get
            {
                return (string)GetValue(WAFPROFProperty);
            }
            set
            {
                SetValue(WAFPROFProperty, value);
                OnWAFPROFChg();
            }
        }
        private static void OnWAFPROFChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFPROF = (string)e.NewValue;
            }
        }
        public virtual void OnWAFPROFChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFPROF=WAFPROF;
        }
         #endregion
       #region ==WARLSTA===========
        public static readonly DependencyProperty WARLSTAProperty = DependencyProperty.Register("WARLSTA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARLSTAChanged));
        public string WARLSTA
        {
            get
            {
                return (string)GetValue(WARLSTAProperty);
            }
            set
            {
                SetValue(WARLSTAProperty, value);
                OnWARLSTAChg();
            }
        }
        private static void OnWARLSTAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARLSTA = (string)e.NewValue;
            }
        }
        public virtual void OnWARLSTAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARLSTA=WARLSTA;
        }
         #endregion
       #region ==WAFLSTA===========
        public static readonly DependencyProperty WAFLSTAProperty = DependencyProperty.Register("WAFLSTA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFLSTAChanged));
        public string WAFLSTA
        {
            get
            {
                return (string)GetValue(WAFLSTAProperty);
            }
            set
            {
                SetValue(WAFLSTAProperty, value);
                OnWAFLSTAChg();
            }
        }
        private static void OnWAFLSTAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFLSTA = (string)e.NewValue;
            }
        }
        public virtual void OnWAFLSTAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFLSTA=WAFLSTA;
        }
         #endregion
       #region ==WARSTAKZ===========
        public static readonly DependencyProperty WARSTAKZProperty = DependencyProperty.Register("WARSTAKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARSTAKZChanged));
        public string WARSTAKZ
        {
            get
            {
                return (string)GetValue(WARSTAKZProperty);
            }
            set
            {
                SetValue(WARSTAKZProperty, value);
                OnWARSTAKZChg();
            }
        }
        private static void OnWARSTAKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARSTAKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWARSTAKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARSTAKZ=WARSTAKZ;
        }
         #endregion
       #region ==WAWAART===========
        public static readonly DependencyProperty WAWAARTProperty = DependencyProperty.Register("WAWAART",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAWAARTChanged));
        public string WAWAART
        {
            get
            {
                return (string)GetValue(WAWAARTProperty);
            }
            set
            {
                SetValue(WAWAARTProperty, value);
                OnWAWAARTChg();
            }
        }
        private static void OnWAWAARTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAWAART = (string)e.NewValue;
            }
        }
        public virtual void OnWAWAARTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAWAART=WAWAART;
        }
         #endregion
       #region ==WARFERTKZ===========
        public static readonly DependencyProperty WARFERTKZProperty = DependencyProperty.Register("WARFERTKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARFERTKZChanged));
        public string WARFERTKZ
        {
            get
            {
                return (string)GetValue(WARFERTKZProperty);
            }
            set
            {
                SetValue(WARFERTKZProperty, value);
                OnWARFERTKZChg();
            }
        }
        private static void OnWARFERTKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARFERTKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWARFERTKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARFERTKZ=WARFERTKZ;
        }
         #endregion
       #region ==WARKL===========
        public static readonly DependencyProperty WARKLProperty = DependencyProperty.Register("WARKL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARKLChanged));
        public string WARKL
        {
            get
            {
                return (string)GetValue(WARKLProperty);
            }
            set
            {
                SetValue(WARKLProperty, value);
                OnWARKLChg();
            }
        }
        private static void OnWARKLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARKL = (string)e.NewValue;
            }
        }
        public virtual void OnWARKLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARKL=WARKL;
        }
         #endregion
       #region ==WARMEHRB===========
        public static readonly DependencyProperty WARMEHRBProperty = DependencyProperty.Register("WARMEHRB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARMEHRBChanged));
        public string WARMEHRB
        {
            get
            {
                return (string)GetValue(WARMEHRBProperty);
            }
            set
            {
                SetValue(WARMEHRBProperty, value);
                OnWARMEHRBChg();
            }
        }
        private static void OnWARMEHRBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARMEHRB = (string)e.NewValue;
            }
        }
        public virtual void OnWARMEHRBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARMEHRB=WARMEHRB;
        }
         #endregion
       #region ==WARVOLL===========
        public static readonly DependencyProperty WARVOLLProperty = DependencyProperty.Register("WARVOLL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARVOLLChanged));
        public string WARVOLL
        {
            get
            {
                return (string)GetValue(WARVOLLProperty);
            }
            set
            {
                SetValue(WARVOLLProperty, value);
                OnWARVOLLChg();
            }
        }
        private static void OnWARVOLLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARVOLL = (string)e.NewValue;
            }
        }
        public virtual void OnWARVOLLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARVOLL=WARVOLL;
        }
         #endregion
       #region ==WARAUFM===========
        public static readonly DependencyProperty WARAUFMProperty = DependencyProperty.Register("WARAUFM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARAUFMChanged));
        public string WARAUFM
        {
            get
            {
                return (string)GetValue(WARAUFMProperty);
            }
            set
            {
                SetValue(WARAUFMProperty, value);
                OnWARAUFMChg();
            }
        }
        private static void OnWARAUFMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARAUFM = (string)e.NewValue;
            }
        }
        public virtual void OnWARAUFMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARAUFM=WARAUFM;
        }
         #endregion
       #region ==WATRAUFM===========
        public static readonly DependencyProperty WATRAUFMProperty = DependencyProperty.Register("WATRAUFM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWATRAUFMChanged));
        public string WATRAUFM
        {
            get
            {
                return (string)GetValue(WATRAUFMProperty);
            }
            set
            {
                SetValue(WATRAUFMProperty, value);
                OnWATRAUFMChg();
            }
        }
        private static void OnWATRAUFMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WATRAUFM = (string)e.NewValue;
            }
        }
        public virtual void OnWATRAUFMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WATRAUFM=WATRAUFM;
        }
         #endregion
       #region ==WATRLG===========
        public static readonly DependencyProperty WATRLGProperty = DependencyProperty.Register("WATRLG",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWATRLGChanged));
        public string WATRLG
        {
            get
            {
                return (string)GetValue(WATRLGProperty);
            }
            set
            {
                SetValue(WATRLGProperty, value);
                OnWATRLGChg();
            }
        }
        private static void OnWATRLGChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WATRLG = (string)e.NewValue;
            }
        }
        public virtual void OnWATRLGChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WATRLG=WATRLG;
        }
         #endregion
   
       #region ==WARMUNR===========
        public static readonly DependencyProperty WARMUNRProperty = DependencyProperty.Register("WARMUNR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARMUNRChanged));
        public string WARMUNR
        {
            get
            {
                return (string)GetValue(WARMUNRProperty);
            }
            set
            {
                SetValue(WARMUNRProperty, value);
                OnWARMUNRChg();
            }
        }
        private static void OnWARMUNRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARMUNR = (string)e.NewValue;
            }
        }
        public virtual void OnWARMUNRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARMUNR=WARMUNR;
        }
         #endregion
       #region ==WARBEM===========
        public static readonly DependencyProperty WARBEMProperty = DependencyProperty.Register("WARBEM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARBEMChanged));
        public string WARBEM
        {
            get
            {
                return (string)GetValue(WARBEMProperty);
            }
            set
            {
                SetValue(WARBEMProperty, value);
                OnWARBEMChg();
            }
        }
        private static void OnWARBEMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARBEM = (string)e.NewValue;
            }
        }
        public virtual void OnWARBEMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARBEM=WARBEM;
        }
         #endregion
       #region ==WATEXTE1===========
        public static readonly DependencyProperty WATEXTE1Property = DependencyProperty.Register("WATEXTE1",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWATEXTE1Changed));
        public string WATEXTE1
        {
            get
            {
                return (string)GetValue(WATEXTE1Property);
            }
            set
            {
                SetValue(WATEXTE1Property, value);
                OnWATEXTE1Chg();
            }
        }
        private static void OnWATEXTE1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WATEXTE1 = (string)e.NewValue;
            }
        }
        public virtual void OnWATEXTE1Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WATEXTE1=WATEXTE1;
        }
         #endregion
       #region ==WATEXTE2===========
        public static readonly DependencyProperty WATEXTE2Property = DependencyProperty.Register("WATEXTE2",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWATEXTE2Changed));
        public string WATEXTE2
        {
            get
            {
                return (string)GetValue(WATEXTE2Property);
            }
            set
            {
                SetValue(WATEXTE2Property, value);
                OnWATEXTE2Chg();
            }
        }
        private static void OnWATEXTE2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WATEXTE2 = (string)e.NewValue;
            }
        }
        public virtual void OnWATEXTE2Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WATEXTE2=WATEXTE2;
        }
         #endregion
       #region ==WATEXTE3===========
        public static readonly DependencyProperty WATEXTE3Property = DependencyProperty.Register("WATEXTE3",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWATEXTE3Changed));
        public string WATEXTE3
        {
            get
            {
                return (string)GetValue(WATEXTE3Property);
            }
            set
            {
                SetValue(WATEXTE3Property, value);
                OnWATEXTE3Chg();
            }
        }
        private static void OnWATEXTE3Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WATEXTE3 = (string)e.NewValue;
            }
        }
        public virtual void OnWATEXTE3Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WATEXTE3=WATEXTE3;
        }
         #endregion
       #region ==WATEXTE4===========
        public static readonly DependencyProperty WATEXTE4Property = DependencyProperty.Register("WATEXTE4",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWATEXTE4Changed));
        public string WATEXTE4
        {
            get
            {
                return (string)GetValue(WATEXTE4Property);
            }
            set
            {
                SetValue(WATEXTE4Property, value);
                OnWATEXTE4Chg();
            }
        }
        private static void OnWATEXTE4Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WATEXTE4 = (string)e.NewValue;
            }
        }
        public virtual void OnWATEXTE4Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WATEXTE4=WATEXTE4;
        }
         #endregion
       #region ==WAKRITI===========
        public static readonly DependencyProperty WAKRITIProperty = DependencyProperty.Register("WAKRITI",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKRITIChanged));
        public string WAKRITI
        {
            get
            {
                return (string)GetValue(WAKRITIProperty);
            }
            set
            {
                SetValue(WAKRITIProperty, value);
                OnWAKRITIChg();
            }
        }
        private static void OnWAKRITIChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKRITI = (string)e.NewValue;
            }
        }
        public virtual void OnWAKRITIChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKRITI=WAKRITI;
        }
         #endregion
       #region ==WARGKZ1===========
        public static readonly DependencyProperty WARGKZ1Property = DependencyProperty.Register("WARGKZ1",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARGKZ1Changed));
        public string WARGKZ1
        {
            get
            {
                return (string)GetValue(WARGKZ1Property);
            }
            set
            {
                SetValue(WARGKZ1Property, value);
                OnWARGKZ1Chg();
            }
        }
        private static void OnWARGKZ1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARGKZ1 = (string)e.NewValue;
            }
        }
        public virtual void OnWARGKZ1Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARGKZ1=WARGKZ1;
        }
         #endregion
       #region ==WAGFKZ===========
        public static readonly DependencyProperty WAGFKZProperty = DependencyProperty.Register("WAGFKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAGFKZChanged));
        public string WAGFKZ
        {
            get
            {
                return (string)GetValue(WAGFKZProperty);
            }
            set
            {
                SetValue(WAGFKZProperty, value);
                OnWAGFKZChg();
            }
        }
        private static void OnWAGFKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAGFKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWAGFKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAGFKZ=WAGFKZ;
        }
         #endregion
       #region ==WARAUFT===========
        public static readonly DependencyProperty WARAUFTProperty = DependencyProperty.Register("WARAUFT",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARAUFTChanged));
        public string WARAUFT
        {
            get
            {
                return (string)GetValue(WARAUFTProperty);
            }
            set
            {
                SetValue(WARAUFTProperty, value);
                OnWARAUFTChg();
            }
        }
        private static void OnWARAUFTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARAUFT = (string)e.NewValue;
            }
        }
        public virtual void OnWARAUFTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARAUFT=WARAUFT;
        }
         #endregion
       #region ==WARAUFD===========
        public static readonly DependencyProperty WARAUFDProperty = DependencyProperty.Register("WARAUFD",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARAUFDChanged));
        public string WARAUFD
        {
            get
            {
                return (string)GetValue(WARAUFDProperty);
            }
            set
            {
                SetValue(WARAUFDProperty, value);
                OnWARAUFDChg();
            }
        }
        private static void OnWARAUFDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARAUFD = (string)e.NewValue;
            }
        }
        public virtual void OnWARAUFDChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARAUFD=WARAUFD;
        }
         #endregion
       #region ==WARUNGLFM===========
        public static readonly DependencyProperty WARUNGLFMProperty = DependencyProperty.Register("WARUNGLFM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARUNGLFMChanged));
        public string WARUNGLFM
        {
            get
            {
                return (string)GetValue(WARUNGLFMProperty);
            }
            set
            {
                SetValue(WARUNGLFMProperty, value);
                OnWARUNGLFMChg();
            }
        }
        private static void OnWARUNGLFMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARUNGLFM = (string)e.NewValue;
            }
        }
        public virtual void OnWARUNGLFMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARUNGLFM=WARUNGLFM;
        }
         #endregion
       #region ==WARUNGQM===========
        public static readonly DependencyProperty WARUNGQMProperty = DependencyProperty.Register("WARUNGQM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARUNGQMChanged));
        public string WARUNGQM
        {
            get
            {
                return (string)GetValue(WARUNGQMProperty);
            }
            set
            {
                SetValue(WARUNGQMProperty, value);
                OnWARUNGQMChg();
            }
        }
        private static void OnWARUNGQMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARUNGQM = (string)e.NewValue;
            }
        }
        public virtual void OnWARUNGQMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARUNGQM=WARUNGQM;
        }
         #endregion
       #region ==WARUNBRT===========
        public static readonly DependencyProperty WARUNBRTProperty = DependencyProperty.Register("WARUNBRT",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARUNBRTChanged));
        public string WARUNBRT
        {
            get
            {
                return (string)GetValue(WARUNBRTProperty);
            }
            set
            {
                SetValue(WARUNBRTProperty, value);
                OnWARUNBRTChg();
            }
        }
        private static void OnWARUNBRTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARUNBRT = (string)e.NewValue;
            }
        }
        public virtual void OnWARUNBRTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARUNBRT=WARUNBRT;
        }
         #endregion
       #region ==WARUNFDK===========
        public static readonly DependencyProperty WARUNFDKProperty = DependencyProperty.Register("WARUNFDK",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARUNFDKChanged));
        public string WARUNFDK
        {
            get
            {
                return (string)GetValue(WARUNFDKProperty);
            }
            set
            {
                SetValue(WARUNFDKProperty, value);
                OnWARUNFDKChg();
            }
        }
        private static void OnWARUNFDKChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARUNFDK = (string)e.NewValue;
            }
        }
        public virtual void OnWARUNFDKChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARUNFDK=WARUNFDK;
        }
         #endregion
       #region ==WARUNFDS===========
        public static readonly DependencyProperty WARUNFDSProperty = DependencyProperty.Register("WARUNFDS",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARUNFDSChanged));
        public string WARUNFDS
        {
            get
            {
                return (string)GetValue(WARUNFDSProperty);
            }
            set
            {
                SetValue(WARUNFDSProperty, value);
                OnWARUNFDSChg();
            }
        }
        private static void OnWARUNFDSChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARUNFDS = (string)e.NewValue;
            }
        }
        public virtual void OnWARUNFDSChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARUNFDS=WARUNFDS;
        }
         #endregion
       #region ==WARWBRT===========
        public static readonly DependencyProperty WARWBRTProperty = DependencyProperty.Register("WARWBRT",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARWBRTChanged));
        public string WARWBRT
        {
            get
            {
                return (string)GetValue(WARWBRTProperty);
            }
            set
            {
                SetValue(WARWBRTProperty, value);
                OnWARWBRTChg();
            }
        }
        private static void OnWARWBRTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARWBRT = (string)e.NewValue;
            }
        }
        public virtual void OnWARWBRTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARWBRT=WARWBRT;
        }
         #endregion
       #region ==WARBRLST===========
        public static readonly DependencyProperty WARBRLSTProperty = DependencyProperty.Register("WARBRLST",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARBRLSTChanged));
        public string WARBRLST
        {
            get
            {
                return (string)GetValue(WARBRLSTProperty);
            }
            set
            {
                SetValue(WARBRLSTProperty, value);
                OnWARBRLSTChg();
            }
        }
        private static void OnWARBRLSTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARBRLST = (string)e.NewValue;
            }
        }
        public virtual void OnWARBRLSTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARBRLST=WARBRLST;
        }
         #endregion
       #region ==WARBRTOL===========
        public static readonly DependencyProperty WARBRTOLProperty = DependencyProperty.Register("WARBRTOL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARBRTOLChanged));
        public string WARBRTOL
        {
            get
            {
                return (string)GetValue(WARBRTOLProperty);
            }
            set
            {
                SetValue(WARBRTOLProperty, value);
                OnWARBRTOLChg();
            }
        }
        private static void OnWARBRTOLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARBRTOL = (string)e.NewValue;
            }
        }
        public virtual void OnWARBRTOLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARBRTOL=WARBRTOL;
        }
         #endregion
       #region ==WARGRQM===========
        public static readonly DependencyProperty WARGRQMProperty = DependencyProperty.Register("WARGRQM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARGRQMChanged));
        public string WARGRQM
        {
            get
            {
                return (string)GetValue(WARGRQMProperty);
            }
            set
            {
                SetValue(WARGRQMProperty, value);
                OnWARGRQMChg();
            }
        }
        private static void OnWARGRQMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARGRQM = (string)e.NewValue;
            }
        }
        public virtual void OnWARGRQMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARGRQM=WARGRQM;
        }
         #endregion
       #region ==WARGRLFD===========
        public static readonly DependencyProperty WARGRLFDProperty = DependencyProperty.Register("WARGRLFD",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARGRLFDChanged));
        public string WARGRLFD
        {
            get
            {
                return (string)GetValue(WARGRLFDProperty);
            }
            set
            {
                SetValue(WARGRLFDProperty, value);
                OnWARGRLFDChg();
            }
        }
        private static void OnWARGRLFDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARGRLFD = (string)e.NewValue;
            }
        }
        public virtual void OnWARGRLFDChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARGRLFD=WARGRLFD;
        }
         #endregion
       #region ==WARGWTOL===========
        public static readonly DependencyProperty WARGWTOLProperty = DependencyProperty.Register("WARGWTOL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARGWTOLChanged));
        public string WARGWTOL
        {
            get
            {
                return (string)GetValue(WARGWTOLProperty);
            }
            set
            {
                SetValue(WARGWTOLProperty, value);
                OnWARGWTOLChg();
            }
        }
        private static void OnWARGWTOLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARGWTOL = (string)e.NewValue;
            }
        }
        public virtual void OnWARGWTOLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARGWTOL=WARGWTOL;
        }
         #endregion
       #region ==WARARTDICKE===========
        public static readonly DependencyProperty WARARTDICKEProperty = DependencyProperty.Register("WARARTDICKE",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARARTDICKEChanged));
        public string WARARTDICKE
        {
            get
            {
                return (string)GetValue(WARARTDICKEProperty);
            }
            set
            {
                SetValue(WARARTDICKEProperty, value);
                OnWARARTDICKEChg();
            }
        }
        private static void OnWARARTDICKEChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARARTDICKE = (string)e.NewValue;
            }
        }
        public virtual void OnWARARTDICKEChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARARTDICKE=WARARTDICKE;
        }
         #endregion
       #region ==WARARTTOLP===========
        public static readonly DependencyProperty WARARTTOLPProperty = DependencyProperty.Register("WARARTTOLP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARARTTOLPChanged));
        public string WARARTTOLP
        {
            get
            {
                return (string)GetValue(WARARTTOLPProperty);
            }
            set
            {
                SetValue(WARARTTOLPProperty, value);
                OnWARARTTOLPChg();
            }
        }
        private static void OnWARARTTOLPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARARTTOLP = (string)e.NewValue;
            }
        }
        public virtual void OnWARARTTOLPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARARTTOLP=WARARTTOLP;
        }
         #endregion
       #region ==WARARTTOLM===========
        public static readonly DependencyProperty WARARTTOLMProperty = DependencyProperty.Register("WARARTTOLM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARARTTOLMChanged));
        public string WARARTTOLM
        {
            get
            {
                return (string)GetValue(WARARTTOLMProperty);
            }
            set
            {
                SetValue(WARARTTOLMProperty, value);
                OnWARARTTOLMChg();
            }
        }
        private static void OnWARARTTOLMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARARTTOLM = (string)e.NewValue;
            }
        }
        public virtual void OnWARARTTOLMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARARTTOLM=WARARTTOLM;
        }
         #endregion
       #region ==WARFDDIK===========
        public static readonly DependencyProperty WARFDDIKProperty = DependencyProperty.Register("WARFDDIK",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARFDDIKChanged));
        public string WARFDDIK
        {
            get
            {
                return (string)GetValue(WARFDDIKProperty);
            }
            set
            {
                SetValue(WARFDDIKProperty, value);
                OnWARFDDIKChg();
            }
        }
        private static void OnWARFDDIKChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARFDDIK = (string)e.NewValue;
            }
        }
        public virtual void OnWARFDDIKChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARFDDIK=WARFDDIK;
        }
         #endregion
       #region ==WARFDDIS===========
        public static readonly DependencyProperty WARFDDISProperty = DependencyProperty.Register("WARFDDIS",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARFDDISChanged));
        public string WARFDDIS
        {
            get
            {
                return (string)GetValue(WARFDDISProperty);
            }
            set
            {
                SetValue(WARFDDISProperty, value);
                OnWARFDDISChg();
            }
        }
        private static void OnWARFDDISChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARFDDIS = (string)e.NewValue;
            }
        }
        public virtual void OnWARFDDISChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARFDDIS=WARFDDIS;
        }
         #endregion
       #region ==WABIND===========
        public static readonly DependencyProperty WABINDProperty = DependencyProperty.Register("WABIND",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWABINDChanged));
        public string WABIND
        {
            get
            {
                return (string)GetValue(WABINDProperty);
            }
            set
            {
                SetValue(WABINDProperty, value);
                OnWABINDChg();
            }
        }
        private static void OnWABINDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WABIND = (string)e.NewValue;
            }
        }
        public virtual void OnWABINDChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WABIND=WABIND;
        }
         #endregion
       #region ==WARIPP===========
        public static readonly DependencyProperty WARIPPProperty = DependencyProperty.Register("WARIPP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARIPPChanged));
        public string WARIPP
        {
            get
            {
                return (string)GetValue(WARIPPProperty);
            }
            set
            {
                SetValue(WARIPPProperty, value);
                OnWARIPPChg();
            }
        }
        private static void OnWARIPPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARIPP = (string)e.NewValue;
            }
        }
        public virtual void OnWARIPPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARIPP=WARIPP;
        }
         #endregion
       #region ==WASCHLICHTGR===========
        public static readonly DependencyProperty WASCHLICHTGRProperty = DependencyProperty.Register("WASCHLICHTGR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASCHLICHTGRChanged));
        public string WASCHLICHTGR
        {
            get
            {
                return (string)GetValue(WASCHLICHTGRProperty);
            }
            set
            {
                SetValue(WASCHLICHTGRProperty, value);
                OnWASCHLICHTGRChg();
            }
        }
        private static void OnWASCHLICHTGRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASCHLICHTGR = (string)e.NewValue;
            }
        }
        public virtual void OnWASCHLICHTGRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASCHLICHTGR=WASCHLICHTGR;
        }
         #endregion
       #region ==WASCHLICHTNR===========
        public static readonly DependencyProperty WASCHLICHTNRProperty = DependencyProperty.Register("WASCHLICHTNR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASCHLICHTNRChanged));
        public string WASCHLICHTNR
        {
            get
            {
                return (string)GetValue(WASCHLICHTNRProperty);
            }
            set
            {
                SetValue(WASCHLICHTNRProperty, value);
                OnWASCHLICHTNRChg();
            }
        }
        private static void OnWASCHLICHTNRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASCHLICHTNR = (string)e.NewValue;
            }
        }
        public virtual void OnWASCHLICHTNRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASCHLICHTNR=WASCHLICHTNR;
        }
         #endregion
       #region ==WAEINZNR===========
        public static readonly DependencyProperty WAEINZNRProperty = DependencyProperty.Register("WAEINZNR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAEINZNRChanged));
        public string WAEINZNR
        {
            get
            {
                return (string)GetValue(WAEINZNRProperty);
            }
            set
            {
                SetValue(WAEINZNRProperty, value);
                OnWAEINZNRChg();
            }
        }
        private static void OnWAEINZNRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAEINZNR = (string)e.NewValue;
            }
        }
        public virtual void OnWAEINZNRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAEINZNR=WAEINZNR;
        }
         #endregion
       #region ==WATSDSCH===========
        public static readonly DependencyProperty WATSDSCHProperty = DependencyProperty.Register("WATSDSCH",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWATSDSCHChanged));
        public string WATSDSCH
        {
            get
            {
                return (string)GetValue(WATSDSCHProperty);
            }
            set
            {
                SetValue(WATSDSCHProperty, value);
                OnWATSDSCHChg();
            }
        }
        private static void OnWATSDSCHChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WATSDSCH = (string)e.NewValue;
            }
        }
        public virtual void OnWATSDSCHChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WATSDSCH=WATSDSCH;
        }
         #endregion
       #region ==WASTTEIL===========
        public static readonly DependencyProperty WASTTEILProperty = DependencyProperty.Register("WASTTEIL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASTTEILChanged));
        public string WASTTEIL
        {
            get
            {
                return (string)GetValue(WASTTEILProperty);
            }
            set
            {
                SetValue(WASTTEILProperty, value);
                OnWASTTEILChg();
            }
        }
        private static void OnWASTTEILChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASTTEIL = (string)e.NewValue;
            }
        }
        public virtual void OnWASTTEILChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASTTEIL=WASTTEIL;
        }
         #endregion
       #region ==WAFSTAKZ===========
        public static readonly DependencyProperty WAFSTAKZProperty = DependencyProperty.Register("WAFSTAKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFSTAKZChanged));
        public string WAFSTAKZ
        {
            get
            {
                return (string)GetValue(WAFSTAKZProperty);
            }
            set
            {
                SetValue(WAFSTAKZProperty, value);
                OnWAFSTAKZChg();
            }
        }
        private static void OnWAFSTAKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFSTAKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWAFSTAKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFSTAKZ=WAFSTAKZ;
        }
         #endregion
       #region ==WAFFERTKZ===========
        public static readonly DependencyProperty WAFFERTKZProperty = DependencyProperty.Register("WAFFERTKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFFERTKZChanged));
        public string WAFFERTKZ
        {
            get
            {
                return (string)GetValue(WAFFERTKZProperty);
            }
            set
            {
                SetValue(WAFFERTKZProperty, value);
                OnWAFFERTKZChg();
            }
        }
        private static void OnWAFFERTKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFFERTKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWAFFERTKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFFERTKZ=WAFFERTKZ;
        }
         #endregion
       #region ==WAAUSART===========
        public static readonly DependencyProperty WAAUSARTProperty = DependencyProperty.Register("WAAUSART",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAAUSARTChanged));
        public string WAAUSART
        {
            get
            {
                return (string)GetValue(WAAUSARTProperty);
            }
            set
            {
                SetValue(WAAUSARTProperty, value);
                OnWAAUSARTChg();
            }
        }
        private static void OnWAAUSARTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAAUSART = (string)e.NewValue;
            }
        }
        public virtual void OnWAAUSARTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAAUSART=WAAUSART;
        }
         #endregion
       #region ==WASTUEART===========
        public static readonly DependencyProperty WASTUEARTProperty = DependencyProperty.Register("WASTUEART",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASTUEARTChanged));
        public string WASTUEART
        {
            get
            {
                return (string)GetValue(WASTUEARTProperty);
            }
            set
            {
                SetValue(WASTUEARTProperty, value);
                OnWASTUEARTChg();
            }
        }
        private static void OnWASTUEARTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASTUEART = (string)e.NewValue;
            }
        }
        public virtual void OnWASTUEARTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASTUEART=WASTUEART;
        }
         #endregion
       #region ==WAVWART===========
        public static readonly DependencyProperty WAVWARTProperty = DependencyProperty.Register("WAVWART",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVWARTChanged));
        public string WAVWART
        {
            get
            {
                return (string)GetValue(WAVWARTProperty);
            }
            set
            {
                SetValue(WAVWARTProperty, value);
                OnWAVWARTChg();
            }
        }
        private static void OnWAVWARTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVWART = (string)e.NewValue;
            }
        }
        public virtual void OnWAVWARTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVWART=WAVWART;
        }
         #endregion
       #region ==WAVWVAR===========
        public static readonly DependencyProperty WAVWVARProperty = DependencyProperty.Register("WAVWVAR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVWVARChanged));
        public string WAVWVAR
        {
            get
            {
                return (string)GetValue(WAVWVARProperty);
            }
            set
            {
                SetValue(WAVWVARProperty, value);
                OnWAVWVARChg();
            }
        }
        private static void OnWAVWVARChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVWVAR = (string)e.NewValue;
            }
        }
        public virtual void OnWAVWVARChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVWVAR=WAVWVAR;
        }
         #endregion
       #region ==WAVARFR===========
        public static readonly DependencyProperty WAVARFRProperty = DependencyProperty.Register("WAVARFR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVARFRChanged));
        public string WAVARFR
        {
            get
            {
                return (string)GetValue(WAVARFRProperty);
            }
            set
            {
                SetValue(WAVARFRProperty, value);
                OnWAVARFRChg();
            }
        }
        private static void OnWAVARFRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVARFR = (string)e.NewValue;
            }
        }
        public virtual void OnWAVARFRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVARFR=WAVARFR;
        }
         #endregion
       #region ==WAFMEHRB===========
        public static readonly DependencyProperty WAFMEHRBProperty = DependencyProperty.Register("WAFMEHRB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFMEHRBChanged));
        public string WAFMEHRB
        {
            get
            {
                return (string)GetValue(WAFMEHRBProperty);
            }
            set
            {
                SetValue(WAFMEHRBProperty, value);
                OnWAFMEHRBChg();
            }
        }
        private static void OnWAFMEHRBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFMEHRB = (string)e.NewValue;
            }
        }
        public virtual void OnWAFMEHRBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFMEHRB=WAFMEHRB;
        }
         #endregion
       #region ==WAFVOLL===========
        public static readonly DependencyProperty WAFVOLLProperty = DependencyProperty.Register("WAFVOLL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFVOLLChanged));
        public string WAFVOLL
        {
            get
            {
                return (string)GetValue(WAFVOLLProperty);
            }
            set
            {
                SetValue(WAFVOLLProperty, value);
                OnWAFVOLLChg();
            }
        }
        private static void OnWAFVOLLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFVOLL = (string)e.NewValue;
            }
        }
        public virtual void OnWAFVOLLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFVOLL=WAFVOLL;
        }
         #endregion
       #region ==WAFAUFM===========
        public static readonly DependencyProperty WAFAUFMProperty = DependencyProperty.Register("WAFAUFM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFAUFMChanged));
        public string WAFAUFM
        {
            get
            {
                return (string)GetValue(WAFAUFMProperty);
            }
            set
            {
                SetValue(WAFAUFMProperty, value);
                OnWAFAUFMChg();
            }
        }
        private static void OnWAFAUFMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFAUFM = (string)e.NewValue;
            }
        }
        public virtual void OnWAFAUFMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFAUFM=WAFAUFM;
        }
         #endregion
       #region ==WAFABLOM===========
        public static readonly DependencyProperty WAFABLOMProperty = DependencyProperty.Register("WAFABLOM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFABLOMChanged));
        public string WAFABLOM
        {
            get
            {
                return (string)GetValue(WAFABLOMProperty);
            }
            set
            {
                SetValue(WAFABLOMProperty, value);
                OnWAFABLOMChg();
            }
        }
        private static void OnWAFABLOMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFABLOM = (string)e.NewValue;
            }
        }
        public virtual void OnWAFABLOMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFABLOM=WAFABLOM;
        }
         #endregion
       #region ==WAGVORL===========
        public static readonly DependencyProperty WAGVORLProperty = DependencyProperty.Register("WAGVORL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAGVORLChanged));
        public string WAGVORL
        {
            get
            {
                return (string)GetValue(WAGVORLProperty);
            }
            set
            {
                SetValue(WAGVORLProperty, value);
                OnWAGVORLChg();
            }
        }
        private static void OnWAGVORLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAGVORL = (string)e.NewValue;
            }
        }
        public virtual void OnWAGVORLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAGVORL=WAGVORL;
        }
         #endregion
       #region ==WAOVORL===========
        public static readonly DependencyProperty WAOVORLProperty = DependencyProperty.Register("WAOVORL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAOVORLChanged));
        public string WAOVORL
        {
            get
            {
                return (string)GetValue(WAOVORLProperty);
            }
            set
            {
                SetValue(WAOVORLProperty, value);
                OnWAOVORLChg();
            }
        }
        private static void OnWAOVORLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAOVORL = (string)e.NewValue;
            }
        }
        public virtual void OnWAOVORLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAOVORL=WAOVORL;
        }
         #endregion
       #region ==WAFRBST===========
        public static readonly DependencyProperty WAFRBSTProperty = DependencyProperty.Register("WAFRBST",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFRBSTChanged));
        public string WAFRBST
        {
            get
            {
                return (string)GetValue(WAFRBSTProperty);
            }
            set
            {
                SetValue(WAFRBSTProperty, value);
                OnWAFRBSTChg();
            }
        }
        private static void OnWAFRBSTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFRBST = (string)e.NewValue;
            }
        }
        public virtual void OnWAFRBSTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFRBST=WAFRBST;
        }
         #endregion
       #region ==WALAMFR===========
        public static readonly DependencyProperty WALAMFRProperty = DependencyProperty.Register("WALAMFR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWALAMFRChanged));
        public string WALAMFR
        {
            get
            {
                return (string)GetValue(WALAMFRProperty);
            }
            set
            {
                SetValue(WALAMFRProperty, value);
                OnWALAMFRChg();
            }
        }
        private static void OnWALAMFRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WALAMFR = (string)e.NewValue;
            }
        }
        public virtual void OnWALAMFRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WALAMFR=WALAMFR;
        }
         #endregion
       #region ==WAFGKZ1===========
        public static readonly DependencyProperty WAFGKZ1Property = DependencyProperty.Register("WAFGKZ1",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFGKZ1Changed));
        public string WAFGKZ1
        {
            get
            {
                return (string)GetValue(WAFGKZ1Property);
            }
            set
            {
                SetValue(WAFGKZ1Property, value);
                OnWAFGKZ1Chg();
            }
        }
        private static void OnWAFGKZ1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFGKZ1 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFGKZ1Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFGKZ1=WAFGKZ1;
        }
         #endregion
       #region ==WAFGKZ2===========
        public static readonly DependencyProperty WAFGKZ2Property = DependencyProperty.Register("WAFGKZ2",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFGKZ2Changed));
        public string WAFGKZ2
        {
            get
            {
                return (string)GetValue(WAFGKZ2Property);
            }
            set
            {
                SetValue(WAFGKZ2Property, value);
                OnWAFGKZ2Chg();
            }
        }
        private static void OnWAFGKZ2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFGKZ2 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFGKZ2Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFGKZ2=WAFGKZ2;
        }
         #endregion
       #region ==WAFGKZ3===========
        public static readonly DependencyProperty WAFGKZ3Property = DependencyProperty.Register("WAFGKZ3",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFGKZ3Changed));
        public string WAFGKZ3
        {
            get
            {
                return (string)GetValue(WAFGKZ3Property);
            }
            set
            {
                SetValue(WAFGKZ3Property, value);
                OnWAFGKZ3Chg();
            }
        }
        private static void OnWAFGKZ3Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFGKZ3 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFGKZ3Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFGKZ3=WAFGKZ3;
        }
         #endregion
       #region ==WASCHLKZ===========
        public static readonly DependencyProperty WASCHLKZProperty = DependencyProperty.Register("WASCHLKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASCHLKZChanged));
        public string WASCHLKZ
        {
            get
            {
                return (string)GetValue(WASCHLKZProperty);
            }
            set
            {
                SetValue(WASCHLKZProperty, value);
                OnWASCHLKZChg();
            }
        }
        private static void OnWASCHLKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASCHLKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWASCHLKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASCHLKZ=WASCHLKZ;
        }
         #endregion
       #region ==WAFAUFT===========
        public static readonly DependencyProperty WAFAUFTProperty = DependencyProperty.Register("WAFAUFT",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFAUFTChanged));
        public string WAFAUFT
        {
            get
            {
                return (string)GetValue(WAFAUFTProperty);
            }
            set
            {
                SetValue(WAFAUFTProperty, value);
                OnWAFAUFTChg();
            }
        }
        private static void OnWAFAUFTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFAUFT = (string)e.NewValue;
            }
        }
        public virtual void OnWAFAUFTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFAUFT=WAFAUFT;
        }
         #endregion
       #region ==WAFAUFD===========
        public static readonly DependencyProperty WAFAUFDProperty = DependencyProperty.Register("WAFAUFD",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFAUFDChanged));
        public string WAFAUFD
        {
            get
            {
                return (string)GetValue(WAFAUFDProperty);
            }
            set
            {
                SetValue(WAFAUFDProperty, value);
                OnWAFAUFDChg();
            }
        }
        private static void OnWAFAUFDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFAUFD = (string)e.NewValue;
            }
        }
        public virtual void OnWAFAUFDChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFAUFD=WAFAUFD;
        }
         #endregion
       #region ==WAFKART===========
        public static readonly DependencyProperty WAFKARTProperty = DependencyProperty.Register("WAFKART",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFKARTChanged));
        public string WAFKART
        {
            get
            {
                return (string)GetValue(WAFKARTProperty);
            }
            set
            {
                SetValue(WAFKARTProperty, value);
                OnWAFKARTChg();
            }
        }
        private static void OnWAFKARTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFKART = (string)e.NewValue;
            }
        }
        public virtual void OnWAFKARTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFKART=WAFKART;
        }
         #endregion
       #region ==WAKOLL===========
        public static readonly DependencyProperty WAKOLLProperty = DependencyProperty.Register("WAKOLL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKOLLChanged));
        public string WAKOLL
        {
            get
            {
                return (string)GetValue(WAKOLLProperty);
            }
            set
            {
                SetValue(WAKOLLProperty, value);
                OnWAKOLLChg();
            }
        }
        private static void OnWAKOLLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKOLL = (string)e.NewValue;
            }
        }
        public virtual void OnWAKOLLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKOLL=WAKOLL;
        }
         #endregion
       #region ==WAFBEM===========
        public static readonly DependencyProperty WAFBEMProperty = DependencyProperty.Register("WAFBEM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFBEMChanged));
        public string WAFBEM
        {
            get
            {
                return (string)GetValue(WAFBEMProperty);
            }
            set
            {
                SetValue(WAFBEMProperty, value);
                OnWAFBEMChg();
            }
        }
        private static void OnWAFBEMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFBEM = (string)e.NewValue;
            }
        }
        public virtual void OnWAFBEMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFBEM=WAFBEM;
        }
         #endregion
       #region ==WAFUNGLFM===========
        public static readonly DependencyProperty WAFUNGLFMProperty = DependencyProperty.Register("WAFUNGLFM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFUNGLFMChanged));
        public string WAFUNGLFM
        {
            get
            {
                return (string)GetValue(WAFUNGLFMProperty);
            }
            set
            {
                SetValue(WAFUNGLFMProperty, value);
                OnWAFUNGLFMChg();
            }
        }
        private static void OnWAFUNGLFMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFUNGLFM = (string)e.NewValue;
            }
        }
        public virtual void OnWAFUNGLFMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFUNGLFM=WAFUNGLFM;
        }
         #endregion
       #region ==WAFUNGQM===========
        public static readonly DependencyProperty WAFUNGQMProperty = DependencyProperty.Register("WAFUNGQM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFUNGQMChanged));
        public string WAFUNGQM
        {
            get
            {
                return (string)GetValue(WAFUNGQMProperty);
            }
            set
            {
                SetValue(WAFUNGQMProperty, value);
                OnWAFUNGQMChg();
            }
        }
        private static void OnWAFUNGQMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFUNGQM = (string)e.NewValue;
            }
        }
        public virtual void OnWAFUNGQMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFUNGQM=WAFUNGQM;
        }
         #endregion
       #region ==WAFUNBRT===========
        public static readonly DependencyProperty WAFUNBRTProperty = DependencyProperty.Register("WAFUNBRT",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFUNBRTChanged));
        public string WAFUNBRT
        {
            get
            {
                return (string)GetValue(WAFUNBRTProperty);
            }
            set
            {
                SetValue(WAFUNBRTProperty, value);
                OnWAFUNBRTChg();
            }
        }
        private static void OnWAFUNBRTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFUNBRT = (string)e.NewValue;
            }
        }
        public virtual void OnWAFUNBRTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFUNBRT=WAFUNBRT;
        }
         #endregion
       #region ==WAFUNFDK===========
        public static readonly DependencyProperty WAFUNFDKProperty = DependencyProperty.Register("WAFUNFDK",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFUNFDKChanged));
        public string WAFUNFDK
        {
            get
            {
                return (string)GetValue(WAFUNFDKProperty);
            }
            set
            {
                SetValue(WAFUNFDKProperty, value);
                OnWAFUNFDKChg();
            }
        }
        private static void OnWAFUNFDKChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFUNFDK = (string)e.NewValue;
            }
        }
        public virtual void OnWAFUNFDKChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFUNFDK=WAFUNFDK;
        }
         #endregion
       #region ==WAFUNFDS===========
        public static readonly DependencyProperty WAFUNFDSProperty = DependencyProperty.Register("WAFUNFDS",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFUNFDSChanged));
        public string WAFUNFDS
        {
            get
            {
                return (string)GetValue(WAFUNFDSProperty);
            }
            set
            {
                SetValue(WAFUNFDSProperty, value);
                OnWAFUNFDSChg();
            }
        }
        private static void OnWAFUNFDSChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFUNFDS = (string)e.NewValue;
            }
        }
        public virtual void OnWAFUNFDSChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFUNFDS=WAFUNFDS;
        }
         #endregion
       #region ==WAFBRTU===========
        public static readonly DependencyProperty WAFBRTUProperty = DependencyProperty.Register("WAFBRTU",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFBRTUChanged));
        public string WAFBRTU
        {
            get
            {
                return (string)GetValue(WAFBRTUProperty);
            }
            set
            {
                SetValue(WAFBRTUProperty, value);
                OnWAFBRTUChg();
            }
        }
        private static void OnWAFBRTUChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFBRTU = (string)e.NewValue;
            }
        }
        public virtual void OnWAFBRTUChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFBRTU=WAFBRTU;
        }
         #endregion
       #region ==WAFBRTUT===========
        public static readonly DependencyProperty WAFBRTUTProperty = DependencyProperty.Register("WAFBRTUT",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFBRTUTChanged));
        public string WAFBRTUT
        {
            get
            {
                return (string)GetValue(WAFBRTUTProperty);
            }
            set
            {
                SetValue(WAFBRTUTProperty, value);
                OnWAFBRTUTChg();
            }
        }
        private static void OnWAFBRTUTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFBRTUT = (string)e.NewValue;
            }
        }
        public virtual void OnWAFBRTUTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFBRTUT=WAFBRTUT;
        }
         #endregion
       #region ==WAFBRTL===========
        public static readonly DependencyProperty WAFBRTLProperty = DependencyProperty.Register("WAFBRTL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFBRTLChanged));
        public string WAFBRTL
        {
            get
            {
                return (string)GetValue(WAFBRTLProperty);
            }
            set
            {
                SetValue(WAFBRTLProperty, value);
                OnWAFBRTLChg();
            }
        }
        private static void OnWAFBRTLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFBRTL = (string)e.NewValue;
            }
        }
        public virtual void OnWAFBRTLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFBRTL=WAFBRTL;
        }
         #endregion
       #region ==WAFBRTLT===========
        public static readonly DependencyProperty WAFBRTLTProperty = DependencyProperty.Register("WAFBRTLT",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFBRTLTChanged));
        public string WAFBRTLT
        {
            get
            {
                return (string)GetValue(WAFBRTLTProperty);
            }
            set
            {
                SetValue(WAFBRTLTProperty, value);
                OnWAFBRTLTChg();
            }
        }
        private static void OnWAFBRTLTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFBRTLT = (string)e.NewValue;
            }
        }
        public virtual void OnWAFBRTLTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFBRTLT=WAFBRTLT;
        }
         #endregion
       #region ==WASCHNK===========
        public static readonly DependencyProperty WASCHNKProperty = DependencyProperty.Register("WASCHNK",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASCHNKChanged));
        public string WASCHNK
        {
            get
            {
                return (string)GetValue(WASCHNKProperty);
            }
            set
            {
                SetValue(WASCHNKProperty, value);
                OnWASCHNKChg();
            }
        }
        private static void OnWASCHNKChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASCHNK = (string)e.NewValue;
            }
        }
        public virtual void OnWASCHNKChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASCHNK=WASCHNK;
        }
         #endregion
       #region ==WALAEAEND===========
        public static readonly DependencyProperty WALAEAENDProperty = DependencyProperty.Register("WALAEAEND",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWALAEAENDChanged));
        public string WALAEAEND
        {
            get
            {
                return (string)GetValue(WALAEAENDProperty);
            }
            set
            {
                SetValue(WALAEAENDProperty, value);
                OnWALAEAENDChg();
            }
        }
        private static void OnWALAEAENDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WALAEAEND = (string)e.NewValue;
            }
        }
        public virtual void OnWALAEAENDChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WALAEAEND=WALAEAEND;
        }
         #endregion
       #region ==WARENDEM===========
        public static readonly DependencyProperty WARENDEMProperty = DependencyProperty.Register("WARENDEM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARENDEMChanged));
        public string WARENDEM
        {
            get
            {
                return (string)GetValue(WARENDEMProperty);
            }
            set
            {
                SetValue(WARENDEMProperty, value);
                OnWARENDEMChg();
            }
        }
        private static void OnWARENDEMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARENDEM = (string)e.NewValue;
            }
        }
        public virtual void OnWARENDEMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARENDEM=WARENDEM;
        }
         #endregion
       #region ==WARENDEMNT===========
        public static readonly DependencyProperty WARENDEMNTProperty = DependencyProperty.Register("WARENDEMNT",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARENDEMNTChanged));
        public string WARENDEMNT
        {
            get
            {
                return (string)GetValue(WARENDEMNTProperty);
            }
            set
            {
                SetValue(WARENDEMNTProperty, value);
                OnWARENDEMNTChg();
            }
        }
        private static void OnWARENDEMNTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARENDEMNT = (string)e.NewValue;
            }
        }
        public virtual void OnWARENDEMNTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARENDEMNT=WARENDEMNT;
        }
         #endregion
       #region ==WAGWVERL===========
        public static readonly DependencyProperty WAGWVERLProperty = DependencyProperty.Register("WAGWVERL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAGWVERLChanged));
        public string WAGWVERL
        {
            get
            {
                return (string)GetValue(WAGWVERLProperty);
            }
            set
            {
                SetValue(WAGWVERLProperty, value);
                OnWAGWVERLChg();
            }
        }
        private static void OnWAGWVERLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAGWVERL = (string)e.NewValue;
            }
        }
        public virtual void OnWAGWVERLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAGWVERL=WAGWVERL;
        }
         #endregion
       #region ==WAALKV===========
        public static readonly DependencyProperty WAALKVProperty = DependencyProperty.Register("WAALKV",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAALKVChanged));
        public string WAALKV
        {
            get
            {
                return (string)GetValue(WAALKVProperty);
            }
            set
            {
                SetValue(WAALKVProperty, value);
                OnWAALKVChg();
            }
        }
        private static void OnWAALKVChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAALKV = (string)e.NewValue;
            }
        }
        public virtual void OnWAALKVChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAALKV=WAALKV;
        }
         #endregion
       #region ==WAFGRQM===========
        public static readonly DependencyProperty WAFGRQMProperty = DependencyProperty.Register("WAFGRQM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFGRQMChanged));
        public string WAFGRQM
        {
            get
            {
                return (string)GetValue(WAFGRQMProperty);
            }
            set
            {
                SetValue(WAFGRQMProperty, value);
                OnWAFGRQMChg();
            }
        }
        private static void OnWAFGRQMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFGRQM = (string)e.NewValue;
            }
        }
        public virtual void OnWAFGRQMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFGRQM=WAFGRQM;
        }
         #endregion
       #region ==WAFGRLFD===========
        public static readonly DependencyProperty WAFGRLFDProperty = DependencyProperty.Register("WAFGRLFD",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFGRLFDChanged));
        public string WAFGRLFD
        {
            get
            {
                return (string)GetValue(WAFGRLFDProperty);
            }
            set
            {
                SetValue(WAFGRLFDProperty, value);
                OnWAFGRLFDChg();
            }
        }
        private static void OnWAFGRLFDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFGRLFD = (string)e.NewValue;
            }
        }
        public virtual void OnWAFGRLFDChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFGRLFD=WAFGRLFD;
        }
         #endregion
       #region ==WAFGWTOL===========
        public static readonly DependencyProperty WAFGWTOLProperty = DependencyProperty.Register("WAFGWTOL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFGWTOLChanged));
        public string WAFGWTOL
        {
            get
            {
                return (string)GetValue(WAFGWTOLProperty);
            }
            set
            {
                SetValue(WAFGWTOLProperty, value);
                OnWAFGWTOLChg();
            }
        }
        private static void OnWAFGWTOLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFGWTOL = (string)e.NewValue;
            }
        }
        public virtual void OnWAFGWTOLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFGWTOL=WAFGWTOL;
        }
         #endregion
       #region ==WAFARTDICKE===========
        public static readonly DependencyProperty WAFARTDICKEProperty = DependencyProperty.Register("WAFARTDICKE",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFARTDICKEChanged));
        public string WAFARTDICKE
        {
            get
            {
                return (string)GetValue(WAFARTDICKEProperty);
            }
            set
            {
                SetValue(WAFARTDICKEProperty, value);
                OnWAFARTDICKEChg();
            }
        }
        private static void OnWAFARTDICKEChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFARTDICKE = (string)e.NewValue;
            }
        }
        public virtual void OnWAFARTDICKEChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFARTDICKE=WAFARTDICKE;
        }
         #endregion
       #region ==WAFARTTOLP===========
        public static readonly DependencyProperty WAFARTTOLPProperty = DependencyProperty.Register("WAFARTTOLP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFARTTOLPChanged));
        public string WAFARTTOLP
        {
            get
            {
                return (string)GetValue(WAFARTTOLPProperty);
            }
            set
            {
                SetValue(WAFARTTOLPProperty, value);
                OnWAFARTTOLPChg();
            }
        }
        private static void OnWAFARTTOLPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFARTTOLP = (string)e.NewValue;
            }
        }
        public virtual void OnWAFARTTOLPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFARTTOLP=WAFARTTOLP;
        }
         #endregion
       #region ==WAFARTTOLM===========
        public static readonly DependencyProperty WAFARTTOLMProperty = DependencyProperty.Register("WAFARTTOLM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFARTTOLMChanged));
        public string WAFARTTOLM
        {
            get
            {
                return (string)GetValue(WAFARTTOLMProperty);
            }
            set
            {
                SetValue(WAFARTTOLMProperty, value);
                OnWAFARTTOLMChg();
            }
        }
        private static void OnWAFARTTOLMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFARTTOLM = (string)e.NewValue;
            }
        }
        public virtual void OnWAFARTTOLMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFARTTOLM=WAFARTTOLM;
        }
         #endregion
       #region ==WAFFDDIK===========
        public static readonly DependencyProperty WAFFDDIKProperty = DependencyProperty.Register("WAFFDDIK",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFFDDIKChanged));
        public string WAFFDDIK
        {
            get
            {
                return (string)GetValue(WAFFDDIKProperty);
            }
            set
            {
                SetValue(WAFFDDIKProperty, value);
                OnWAFFDDIKChg();
            }
        }
        private static void OnWAFFDDIKChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFFDDIK = (string)e.NewValue;
            }
        }
        public virtual void OnWAFFDDIKChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFFDDIK=WAFFDDIK;
        }
         #endregion
       #region ==WAFFDDIS===========
        public static readonly DependencyProperty WAFFDDISProperty = DependencyProperty.Register("WAFFDDIS",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFFDDISChanged));
        public string WAFFDDIS
        {
            get
            {
                return (string)GetValue(WAFFDDISProperty);
            }
            set
            {
                SetValue(WAFFDDISProperty, value);
                OnWAFFDDISChg();
            }
        }
        private static void OnWAFFDDISChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFFDDIS = (string)e.NewValue;
            }
        }
        public virtual void OnWAFFDDISChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFFDDIS=WAFFDDIS;
        }
         #endregion
       #region ==WAUNI===========
        public static readonly DependencyProperty WAUNIProperty = DependencyProperty.Register("WAUNI",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAUNIChanged));
        public string WAUNI
        {
            get
            {
                return (string)GetValue(WAUNIProperty);
            }
            set
            {
                SetValue(WAUNIProperty, value);
                OnWAUNIChg();
            }
        }
        private static void OnWAUNIChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAUNI = (string)e.NewValue;
            }
        }
        public virtual void OnWAUNIChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAUNI=WAUNI;
        }
         #endregion
       #region ==WACOLORKZ===========
        public static readonly DependencyProperty WACOLORKZProperty = DependencyProperty.Register("WACOLORKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWACOLORKZChanged));
        public string WACOLORKZ
        {
            get
            {
                return (string)GetValue(WACOLORKZProperty);
            }
            set
            {
                SetValue(WACOLORKZProperty, value);
                OnWACOLORKZChg();
            }
        }
        private static void OnWACOLORKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WACOLORKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWACOLORKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WACOLORKZ=WACOLORKZ;
        }
         #endregion
       #region ==WAUNIGA===========
        public static readonly DependencyProperty WAUNIGAProperty = DependencyProperty.Register("WAUNIGA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAUNIGAChanged));
        public string WAUNIGA
        {
            get
            {
                return (string)GetValue(WAUNIGAProperty);
            }
            set
            {
                SetValue(WAUNIGAProperty, value);
                OnWAUNIGAChg();
            }
        }
        private static void OnWAUNIGAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAUNIGA = (string)e.NewValue;
            }
        }
        public virtual void OnWAUNIGAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAUNIGA=WAUNIGA;
        }
         #endregion
       #region ==WAGEWICHT2===========
        public static readonly DependencyProperty WAGEWICHT2Property = DependencyProperty.Register("WAGEWICHT2",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAGEWICHT2Changed));
        public string WAGEWICHT2
        {
            get
            {
                return (string)GetValue(WAGEWICHT2Property);
            }
            set
            {
                SetValue(WAGEWICHT2Property, value);
                OnWAGEWICHT2Chg();
            }
        }
        private static void OnWAGEWICHT2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAGEWICHT2 = (string)e.NewValue;
            }
        }
        public virtual void OnWAGEWICHT2Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAGEWICHT2=WAGEWICHT2;
        }
         #endregion
       #region ==WAFVERF1===========
        public static readonly DependencyProperty WAFVERF1Property = DependencyProperty.Register("WAFVERF1",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFVERF1Changed));
        public string WAFVERF1
        {
            get
            {
                return (string)GetValue(WAFVERF1Property);
            }
            set
            {
                SetValue(WAFVERF1Property, value);
                OnWAFVERF1Chg();
            }
        }
        private static void OnWAFVERF1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFVERF1 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFVERF1Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFVERF1=WAFVERF1;
        }
         #endregion
       #region ==WAFVERF2===========
        public static readonly DependencyProperty WAFVERF2Property = DependencyProperty.Register("WAFVERF2",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFVERF2Changed));
        public string WAFVERF2
        {
            get
            {
                return (string)GetValue(WAFVERF2Property);
            }
            set
            {
                SetValue(WAFVERF2Property, value);
                OnWAFVERF2Chg();
            }
        }
        private static void OnWAFVERF2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFVERF2 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFVERF2Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFVERF2=WAFVERF2;
        }
         #endregion
       #region ==WAFVERF3===========
        public static readonly DependencyProperty WAFVERF3Property = DependencyProperty.Register("WAFVERF3",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFVERF3Changed));
        public string WAFVERF3
        {
            get
            {
                return (string)GetValue(WAFVERF3Property);
            }
            set
            {
                SetValue(WAFVERF3Property, value);
                OnWAFVERF3Chg();
            }
        }
        private static void OnWAFVERF3Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFVERF3 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFVERF3Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFVERF3=WAFVERF3;
        }
         #endregion
       #region ==WAFVERF4===========
        public static readonly DependencyProperty WAFVERF4Property = DependencyProperty.Register("WAFVERF4",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFVERF4Changed));
        public string WAFVERF4
        {
            get
            {
                return (string)GetValue(WAFVERF4Property);
            }
            set
            {
                SetValue(WAFVERF4Property, value);
                OnWAFVERF4Chg();
            }
        }
        private static void OnWAFVERF4Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFVERF4 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFVERF4Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFVERF4=WAFVERF4;
        }
         #endregion
       #region ==WAFZUSTAND1===========
        public static readonly DependencyProperty WAFZUSTAND1Property = DependencyProperty.Register("WAFZUSTAND1",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFZUSTAND1Changed));
        public string WAFZUSTAND1
        {
            get
            {
                return (string)GetValue(WAFZUSTAND1Property);
            }
            set
            {
                SetValue(WAFZUSTAND1Property, value);
                OnWAFZUSTAND1Chg();
            }
        }
        private static void OnWAFZUSTAND1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFZUSTAND1 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFZUSTAND1Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFZUSTAND1=WAFZUSTAND1;
        }
         #endregion
       #region ==WAFZUSTAND2===========
        public static readonly DependencyProperty WAFZUSTAND2Property = DependencyProperty.Register("WAFZUSTAND2",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFZUSTAND2Changed));
        public string WAFZUSTAND2
        {
            get
            {
                return (string)GetValue(WAFZUSTAND2Property);
            }
            set
            {
                SetValue(WAFZUSTAND2Property, value);
                OnWAFZUSTAND2Chg();
            }
        }
        private static void OnWAFZUSTAND2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFZUSTAND2 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFZUSTAND2Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFZUSTAND2=WAFZUSTAND2;
        }
         #endregion
       #region ==WAFZUSTAND3===========
        public static readonly DependencyProperty WAFZUSTAND3Property = DependencyProperty.Register("WAFZUSTAND3",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFZUSTAND3Changed));
        public string WAFZUSTAND3
        {
            get
            {
                return (string)GetValue(WAFZUSTAND3Property);
            }
            set
            {
                SetValue(WAFZUSTAND3Property, value);
                OnWAFZUSTAND3Chg();
            }
        }
        private static void OnWAFZUSTAND3Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFZUSTAND3 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFZUSTAND3Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFZUSTAND3=WAFZUSTAND3;
        }
         #endregion
       #region ==WAFZUSTAND4===========
        public static readonly DependencyProperty WAFZUSTAND4Property = DependencyProperty.Register("WAFZUSTAND4",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFZUSTAND4Changed));
        public string WAFZUSTAND4
        {
            get
            {
                return (string)GetValue(WAFZUSTAND4Property);
            }
            set
            {
                SetValue(WAFZUSTAND4Property, value);
                OnWAFZUSTAND4Chg();
            }
        }
        private static void OnWAFZUSTAND4Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFZUSTAND4 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFZUSTAND4Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFZUSTAND4=WAFZUSTAND4;
        }
         #endregion
       #region ==WAFVERFN1===========
        public static readonly DependencyProperty WAFVERFN1Property = DependencyProperty.Register("WAFVERFN1",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFVERFN1Changed));
        public string WAFVERFN1
        {
            get
            {
                return (string)GetValue(WAFVERFN1Property);
            }
            set
            {
                SetValue(WAFVERFN1Property, value);
                OnWAFVERFN1Chg();
            }
        }
        private static void OnWAFVERFN1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFVERFN1 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFVERFN1Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFVERFN1=WAFVERFN1;
        }
         #endregion
       #region ==WAFVERFN2===========
        public static readonly DependencyProperty WAFVERFN2Property = DependencyProperty.Register("WAFVERFN2",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFVERFN2Changed));
        public string WAFVERFN2
        {
            get
            {
                return (string)GetValue(WAFVERFN2Property);
            }
            set
            {
                SetValue(WAFVERFN2Property, value);
                OnWAFVERFN2Chg();
            }
        }
        private static void OnWAFVERFN2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFVERFN2 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFVERFN2Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFVERFN2=WAFVERFN2;
        }
         #endregion
       #region ==WAFVERFN3===========
        public static readonly DependencyProperty WAFVERFN3Property = DependencyProperty.Register("WAFVERFN3",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFVERFN3Changed));
        public string WAFVERFN3
        {
            get
            {
                return (string)GetValue(WAFVERFN3Property);
            }
            set
            {
                SetValue(WAFVERFN3Property, value);
                OnWAFVERFN3Chg();
            }
        }
        private static void OnWAFVERFN3Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFVERFN3 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFVERFN3Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFVERFN3=WAFVERFN3;
        }
         #endregion
       #region ==WAFVERFN4===========
        public static readonly DependencyProperty WAFVERFN4Property = DependencyProperty.Register("WAFVERFN4",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFVERFN4Changed));
        public string WAFVERFN4
        {
            get
            {
                return (string)GetValue(WAFVERFN4Property);
            }
            set
            {
                SetValue(WAFVERFN4Property, value);
                OnWAFVERFN4Chg();
            }
        }
        private static void OnWAFVERFN4Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFVERFN4 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFVERFN4Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFVERFN4=WAFVERFN4;
        }
         #endregion
       #region ==WAFFGRPN1===========
        public static readonly DependencyProperty WAFFGRPN1Property = DependencyProperty.Register("WAFFGRPN1",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFFGRPN1Changed));
        public string WAFFGRPN1
        {
            get
            {
                return (string)GetValue(WAFFGRPN1Property);
            }
            set
            {
                SetValue(WAFFGRPN1Property, value);
                OnWAFFGRPN1Chg();
            }
        }
        private static void OnWAFFGRPN1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFFGRPN1 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFFGRPN1Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFFGRPN1=WAFFGRPN1;
        }
         #endregion
       #region ==WAFFGRPN2===========
        public static readonly DependencyProperty WAFFGRPN2Property = DependencyProperty.Register("WAFFGRPN2",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFFGRPN2Changed));
        public string WAFFGRPN2
        {
            get
            {
                return (string)GetValue(WAFFGRPN2Property);
            }
            set
            {
                SetValue(WAFFGRPN2Property, value);
                OnWAFFGRPN2Chg();
            }
        }
        private static void OnWAFFGRPN2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFFGRPN2 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFFGRPN2Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFFGRPN2=WAFFGRPN2;
        }
         #endregion
       #region ==WAFFGRPN3===========
        public static readonly DependencyProperty WAFFGRPN3Property = DependencyProperty.Register("WAFFGRPN3",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFFGRPN3Changed));
        public string WAFFGRPN3
        {
            get
            {
                return (string)GetValue(WAFFGRPN3Property);
            }
            set
            {
                SetValue(WAFFGRPN3Property, value);
                OnWAFFGRPN3Chg();
            }
        }
        private static void OnWAFFGRPN3Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFFGRPN3 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFFGRPN3Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFFGRPN3=WAFFGRPN3;
        }
         #endregion
       #region ==WAFFGRPN4===========
        public static readonly DependencyProperty WAFFGRPN4Property = DependencyProperty.Register("WAFFGRPN4",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFFGRPN4Changed));
        public string WAFFGRPN4
        {
            get
            {
                return (string)GetValue(WAFFGRPN4Property);
            }
            set
            {
                SetValue(WAFFGRPN4Property, value);
                OnWAFFGRPN4Chg();
            }
        }
        private static void OnWAFFGRPN4Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFFGRPN4 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFFGRPN4Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFFGRPN4=WAFFGRPN4;
        }
         #endregion
       #region ==WAVNRKZ===========
        public static readonly DependencyProperty WAVNRKZProperty = DependencyProperty.Register("WAVNRKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVNRKZChanged));
        public string WAVNRKZ
        {
            get
            {
                return (string)GetValue(WAVNRKZProperty);
            }
            set
            {
                SetValue(WAVNRKZProperty, value);
                OnWAVNRKZChg();
            }
        }
        private static void OnWAVNRKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVNRKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWAVNRKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVNRKZ=WAVNRKZ;
        }
         #endregion
       #region ==WAZUSTKZ===========
        public static readonly DependencyProperty WAZUSTKZProperty = DependencyProperty.Register("WAZUSTKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAZUSTKZChanged));
        public string WAZUSTKZ
        {
            get
            {
                return (string)GetValue(WAZUSTKZProperty);
            }
            set
            {
                SetValue(WAZUSTKZProperty, value);
                OnWAZUSTKZChg();
            }
        }
        private static void OnWAZUSTKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAZUSTKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWAZUSTKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAZUSTKZ=WAZUSTKZ;
        }
         #endregion
       #region ==WAUEKLOKZ===========
        public static readonly DependencyProperty WAUEKLOKZProperty = DependencyProperty.Register("WAUEKLOKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAUEKLOKZChanged));
        public string WAUEKLOKZ
        {
            get
            {
                return (string)GetValue(WAUEKLOKZProperty);
            }
            set
            {
                SetValue(WAUEKLOKZProperty, value);
                OnWAUEKLOKZChg();
            }
        }
        private static void OnWAUEKLOKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAUEKLOKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWAUEKLOKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAUEKLOKZ=WAUEKLOKZ;
        }
         #endregion
       #region ==WAFSUBST===========
        public static readonly DependencyProperty WAFSUBSTProperty = DependencyProperty.Register("WAFSUBST",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFSUBSTChanged));
        public string WAFSUBST
        {
            get
            {
                return (string)GetValue(WAFSUBSTProperty);
            }
            set
            {
                SetValue(WAFSUBSTProperty, value);
                OnWAFSUBSTChg();
            }
        }
        private static void OnWAFSUBSTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFSUBST = (string)e.NewValue;
            }
        }
        public virtual void OnWAFSUBSTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFSUBST=WAFSUBST;
        }
         #endregion
       #region ==WAMAXFA===========
        public static readonly DependencyProperty WAMAXFAProperty = DependencyProperty.Register("WAMAXFA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMAXFAChanged));
        public string WAMAXFA
        {
            get
            {
                return (string)GetValue(WAMAXFAProperty);
            }
            set
            {
                SetValue(WAMAXFAProperty, value);
                OnWAMAXFAChg();
            }
        }
        private static void OnWAMAXFAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMAXFA = (string)e.NewValue;
            }
        }
        public virtual void OnWAMAXFAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMAXFA=WAMAXFA;
        }
         #endregion
       #region ==WAAKZWG===========
        public static readonly DependencyProperty WAAKZWGProperty = DependencyProperty.Register("WAAKZWG",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAAKZWGChanged));
        public string WAAKZWG
        {
            get
            {
                return (string)GetValue(WAAKZWGProperty);
            }
            set
            {
                SetValue(WAAKZWGProperty, value);
                OnWAAKZWGChg();
            }
        }
        private static void OnWAAKZWGChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAAKZWG = (string)e.NewValue;
            }
        }
        public virtual void OnWAAKZWGChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAAKZWG=WAAKZWG;
        }
         #endregion
       #region ==WAFRESTF===========
        public static readonly DependencyProperty WAFRESTFProperty = DependencyProperty.Register("WAFRESTF",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFRESTFChanged));
        public string WAFRESTF
        {
            get
            {
                return (string)GetValue(WAFRESTFProperty);
            }
            set
            {
                SetValue(WAFRESTFProperty, value);
                OnWAFRESTFChg();
            }
        }
        private static void OnWAFRESTFChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFRESTF = (string)e.NewValue;
            }
        }
        public virtual void OnWAFRESTFChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFRESTF=WAFRESTF;
        }
         #endregion
       #region ==WADRUCKBAR===========
        public static readonly DependencyProperty WADRUCKBARProperty = DependencyProperty.Register("WADRUCKBAR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADRUCKBARChanged));
        public string WADRUCKBAR
        {
            get
            {
                return (string)GetValue(WADRUCKBARProperty);
            }
            set
            {
                SetValue(WADRUCKBARProperty, value);
                OnWADRUCKBARChg();
            }
        }
        private static void OnWADRUCKBARChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADRUCKBAR = (string)e.NewValue;
            }
        }
        public virtual void OnWADRUCKBARChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADRUCKBAR=WADRUCKBAR;
        }
         #endregion
       #region ==WAVBRGQM===========
        public static readonly DependencyProperty WAVBRGQMProperty = DependencyProperty.Register("WAVBRGQM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVBRGQMChanged));
        public string WAVBRGQM
        {
            get
            {
                return (string)GetValue(WAVBRGQMProperty);
            }
            set
            {
                SetValue(WAVBRGQMProperty, value);
                OnWAVBRGQMChg();
            }
        }
        private static void OnWAVBRGQMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVBRGQM = (string)e.NewValue;
            }
        }
        public virtual void OnWAVBRGQMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVBRGQM=WAVBRGQM;
        }
         #endregion
       #region ==WALEDR===========
        public static readonly DependencyProperty WALEDRProperty = DependencyProperty.Register("WALEDR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWALEDRChanged));
        public string WALEDR
        {
            get
            {
                return (string)GetValue(WALEDRProperty);
            }
            set
            {
                SetValue(WALEDRProperty, value);
                OnWALEDRChg();
            }
        }
        private static void OnWALEDRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WALEDR = (string)e.NewValue;
            }
        }
        public virtual void OnWALEDRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WALEDR=WALEDR;
        }
         #endregion
       #region ==WADVERF1===========
        public static readonly DependencyProperty WADVERF1Property = DependencyProperty.Register("WADVERF1",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADVERF1Changed));
        public string WADVERF1
        {
            get
            {
                return (string)GetValue(WADVERF1Property);
            }
            set
            {
                SetValue(WADVERF1Property, value);
                OnWADVERF1Chg();
            }
        }
        private static void OnWADVERF1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADVERF1 = (string)e.NewValue;
            }
        }
        public virtual void OnWADVERF1Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADVERF1=WADVERF1;
        }
         #endregion
       #region ==WADVERF2===========
        public static readonly DependencyProperty WADVERF2Property = DependencyProperty.Register("WADVERF2",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADVERF2Changed));
        public string WADVERF2
        {
            get
            {
                return (string)GetValue(WADVERF2Property);
            }
            set
            {
                SetValue(WADVERF2Property, value);
                OnWADVERF2Chg();
            }
        }
        private static void OnWADVERF2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADVERF2 = (string)e.NewValue;
            }
        }
        public virtual void OnWADVERF2Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADVERF2=WADVERF2;
        }
         #endregion
       #region ==WADVERF3===========
        public static readonly DependencyProperty WADVERF3Property = DependencyProperty.Register("WADVERF3",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADVERF3Changed));
        public string WADVERF3
        {
            get
            {
                return (string)GetValue(WADVERF3Property);
            }
            set
            {
                SetValue(WADVERF3Property, value);
                OnWADVERF3Chg();
            }
        }
        private static void OnWADVERF3Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADVERF3 = (string)e.NewValue;
            }
        }
        public virtual void OnWADVERF3Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADVERF3=WADVERF3;
        }
         #endregion
       #region ==WADVERF4===========
        public static readonly DependencyProperty WADVERF4Property = DependencyProperty.Register("WADVERF4",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADVERF4Changed));
        public string WADVERF4
        {
            get
            {
                return (string)GetValue(WADVERF4Property);
            }
            set
            {
                SetValue(WADVERF4Property, value);
                OnWADVERF4Chg();
            }
        }
        private static void OnWADVERF4Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADVERF4 = (string)e.NewValue;
            }
        }
        public virtual void OnWADVERF4Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADVERF4=WADVERF4;
        }
         #endregion
       #region ==WADZUSTAND1===========
        public static readonly DependencyProperty WADZUSTAND1Property = DependencyProperty.Register("WADZUSTAND1",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADZUSTAND1Changed));
        public string WADZUSTAND1
        {
            get
            {
                return (string)GetValue(WADZUSTAND1Property);
            }
            set
            {
                SetValue(WADZUSTAND1Property, value);
                OnWADZUSTAND1Chg();
            }
        }
        private static void OnWADZUSTAND1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADZUSTAND1 = (string)e.NewValue;
            }
        }
        public virtual void OnWADZUSTAND1Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADZUSTAND1=WADZUSTAND1;
        }
         #endregion
       #region ==WADZUSTAND2===========
        public static readonly DependencyProperty WADZUSTAND2Property = DependencyProperty.Register("WADZUSTAND2",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADZUSTAND2Changed));
        public string WADZUSTAND2
        {
            get
            {
                return (string)GetValue(WADZUSTAND2Property);
            }
            set
            {
                SetValue(WADZUSTAND2Property, value);
                OnWADZUSTAND2Chg();
            }
        }
        private static void OnWADZUSTAND2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADZUSTAND2 = (string)e.NewValue;
            }
        }
        public virtual void OnWADZUSTAND2Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADZUSTAND2=WADZUSTAND2;
        }
         #endregion
       #region ==WADZUSTAND3===========
        public static readonly DependencyProperty WADZUSTAND3Property = DependencyProperty.Register("WADZUSTAND3",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADZUSTAND3Changed));
        public string WADZUSTAND3
        {
            get
            {
                return (string)GetValue(WADZUSTAND3Property);
            }
            set
            {
                SetValue(WADZUSTAND3Property, value);
                OnWADZUSTAND3Chg();
            }
        }
        private static void OnWADZUSTAND3Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADZUSTAND3 = (string)e.NewValue;
            }
        }
        public virtual void OnWADZUSTAND3Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADZUSTAND3=WADZUSTAND3;
        }
         #endregion
       #region ==WADZUSTAND4===========
        public static readonly DependencyProperty WADZUSTAND4Property = DependencyProperty.Register("WADZUSTAND4",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADZUSTAND4Changed));
        public string WADZUSTAND4
        {
            get
            {
                return (string)GetValue(WADZUSTAND4Property);
            }
            set
            {
                SetValue(WADZUSTAND4Property, value);
                OnWADZUSTAND4Chg();
            }
        }
        private static void OnWADZUSTAND4Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADZUSTAND4 = (string)e.NewValue;
            }
        }
        public virtual void OnWADZUSTAND4Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADZUSTAND4=WADZUSTAND4;
        }
         #endregion
       #region ==WADVERFN1===========
        public static readonly DependencyProperty WADVERFN1Property = DependencyProperty.Register("WADVERFN1",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADVERFN1Changed));
        public string WADVERFN1
        {
            get
            {
                return (string)GetValue(WADVERFN1Property);
            }
            set
            {
                SetValue(WADVERFN1Property, value);
                OnWADVERFN1Chg();
            }
        }
        private static void OnWADVERFN1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADVERFN1 = (string)e.NewValue;
            }
        }
        public virtual void OnWADVERFN1Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADVERFN1=WADVERFN1;
        }
         #endregion
       #region ==WADVERFN2===========
        public static readonly DependencyProperty WADVERFN2Property = DependencyProperty.Register("WADVERFN2",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADVERFN2Changed));
        public string WADVERFN2
        {
            get
            {
                return (string)GetValue(WADVERFN2Property);
            }
            set
            {
                SetValue(WADVERFN2Property, value);
                OnWADVERFN2Chg();
            }
        }
        private static void OnWADVERFN2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADVERFN2 = (string)e.NewValue;
            }
        }
        public virtual void OnWADVERFN2Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADVERFN2=WADVERFN2;
        }
         #endregion
       #region ==WADVERFN3===========
        public static readonly DependencyProperty WADVERFN3Property = DependencyProperty.Register("WADVERFN3",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADVERFN3Changed));
        public string WADVERFN3
        {
            get
            {
                return (string)GetValue(WADVERFN3Property);
            }
            set
            {
                SetValue(WADVERFN3Property, value);
                OnWADVERFN3Chg();
            }
        }
        private static void OnWADVERFN3Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADVERFN3 = (string)e.NewValue;
            }
        }
        public virtual void OnWADVERFN3Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADVERFN3=WADVERFN3;
        }
         #endregion
       #region ==WADVERFN4===========
        public static readonly DependencyProperty WADVERFN4Property = DependencyProperty.Register("WADVERFN4",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADVERFN4Changed));
        public string WADVERFN4
        {
            get
            {
                return (string)GetValue(WADVERFN4Property);
            }
            set
            {
                SetValue(WADVERFN4Property, value);
                OnWADVERFN4Chg();
            }
        }
        private static void OnWADVERFN4Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADVERFN4 = (string)e.NewValue;
            }
        }
        public virtual void OnWADVERFN4Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADVERFN4=WADVERFN4;
        }
         #endregion
       #region ==WADFGRPN1===========
        public static readonly DependencyProperty WADFGRPN1Property = DependencyProperty.Register("WADFGRPN1",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADFGRPN1Changed));
        public string WADFGRPN1
        {
            get
            {
                return (string)GetValue(WADFGRPN1Property);
            }
            set
            {
                SetValue(WADFGRPN1Property, value);
                OnWADFGRPN1Chg();
            }
        }
        private static void OnWADFGRPN1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADFGRPN1 = (string)e.NewValue;
            }
        }
        public virtual void OnWADFGRPN1Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADFGRPN1=WADFGRPN1;
        }
         #endregion
       #region ==WADFGRPN2===========
        public static readonly DependencyProperty WADFGRPN2Property = DependencyProperty.Register("WADFGRPN2",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADFGRPN2Changed));
        public string WADFGRPN2
        {
            get
            {
                return (string)GetValue(WADFGRPN2Property);
            }
            set
            {
                SetValue(WADFGRPN2Property, value);
                OnWADFGRPN2Chg();
            }
        }
        private static void OnWADFGRPN2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADFGRPN2 = (string)e.NewValue;
            }
        }
        public virtual void OnWADFGRPN2Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADFGRPN2=WADFGRPN2;
        }
         #endregion
       #region ==WADFGRPN3===========
        public static readonly DependencyProperty WADFGRPN3Property = DependencyProperty.Register("WADFGRPN3",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADFGRPN3Changed));
        public string WADFGRPN3
        {
            get
            {
                return (string)GetValue(WADFGRPN3Property);
            }
            set
            {
                SetValue(WADFGRPN3Property, value);
                OnWADFGRPN3Chg();
            }
        }
        private static void OnWADFGRPN3Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADFGRPN3 = (string)e.NewValue;
            }
        }
        public virtual void OnWADFGRPN3Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADFGRPN3=WADFGRPN3;
        }
         #endregion
       #region ==WADFGRPN4===========
        public static readonly DependencyProperty WADFGRPN4Property = DependencyProperty.Register("WADFGRPN4",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADFGRPN4Changed));
        public string WADFGRPN4
        {
            get
            {
                return (string)GetValue(WADFGRPN4Property);
            }
            set
            {
                SetValue(WADFGRPN4Property, value);
                OnWADFGRPN4Chg();
            }
        }
        private static void OnWADFGRPN4Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADFGRPN4 = (string)e.NewValue;
            }
        }
        public virtual void OnWADFGRPN4Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADFGRPN4=WADFGRPN4;
        }
         #endregion
       #region ==WADSUBST===========
        public static readonly DependencyProperty WADSUBSTProperty = DependencyProperty.Register("WADSUBST",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADSUBSTChanged));
        public string WADSUBST
        {
            get
            {
                return (string)GetValue(WADSUBSTProperty);
            }
            set
            {
                SetValue(WADSUBSTProperty, value);
                OnWADSUBSTChg();
            }
        }
        private static void OnWADSUBSTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADSUBST = (string)e.NewValue;
            }
        }
        public virtual void OnWADSUBSTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADSUBST=WADSUBST;
        }
         #endregion
       #region ==WADRESTF===========
        public static readonly DependencyProperty WADRESTFProperty = DependencyProperty.Register("WADRESTF",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADRESTFChanged));
        public string WADRESTF
        {
            get
            {
                return (string)GetValue(WADRESTFProperty);
            }
            set
            {
                SetValue(WADRESTFProperty, value);
                OnWADRESTFChg();
            }
        }
        private static void OnWADRESTFChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADRESTF = (string)e.NewValue;
            }
        }
        public virtual void OnWADRESTFChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADRESTF=WADRESTF;
        }
         #endregion
       #region ==WAFAKTOR===========
        public static readonly DependencyProperty WAFAKTORProperty = DependencyProperty.Register("WAFAKTOR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFAKTORChanged));
        public string WAFAKTOR
        {
            get
            {
                return (string)GetValue(WAFAKTORProperty);
            }
            set
            {
                SetValue(WAFAKTORProperty, value);
                OnWAFAKTORChg();
            }
        }
        private static void OnWAFAKTORChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFAKTOR = (string)e.NewValue;
            }
        }
        public virtual void OnWAFAKTORChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFAKTOR=WAFAKTOR;
        }
         #endregion
       #region ==WABSUBST===========
        public static readonly DependencyProperty WABSUBSTProperty = DependencyProperty.Register("WABSUBST",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWABSUBSTChanged));
        public string WABSUBST
        {
            get
            {
                return (string)GetValue(WABSUBSTProperty);
            }
            set
            {
                SetValue(WABSUBSTProperty, value);
                OnWABSUBSTChg();
            }
        }
        private static void OnWABSUBSTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WABSUBST = (string)e.NewValue;
            }
        }
        public virtual void OnWABSUBSTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WABSUBST=WABSUBST;
        }
         #endregion
       #region ==WAVORBWA===========
        public static readonly DependencyProperty WAVORBWAProperty = DependencyProperty.Register("WAVORBWA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVORBWAChanged));
        public string WAVORBWA
        {
            get
            {
                return (string)GetValue(WAVORBWAProperty);
            }
            set
            {
                SetValue(WAVORBWAProperty, value);
                OnWAVORBWAChg();
            }
        }
        private static void OnWAVORBWAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVORBWA = (string)e.NewValue;
            }
        }
        public virtual void OnWAVORBWAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVORBWA=WAVORBWA;
        }
         #endregion
       #region ==WANACHBWA===========
        public static readonly DependencyProperty WANACHBWAProperty = DependencyProperty.Register("WANACHBWA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWANACHBWAChanged));
        public string WANACHBWA
        {
            get
            {
                return (string)GetValue(WANACHBWAProperty);
            }
            set
            {
                SetValue(WANACHBWAProperty, value);
                OnWANACHBWAChg();
            }
        }
        private static void OnWANACHBWAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WANACHBWA = (string)e.NewValue;
            }
        }
        public virtual void OnWANACHBWAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WANACHBWA=WANACHBWA;
        }
         #endregion
       #region ==WAVORBFB===========
        public static readonly DependencyProperty WAVORBFBProperty = DependencyProperty.Register("WAVORBFB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVORBFBChanged));
        public string WAVORBFB
        {
            get
            {
                return (string)GetValue(WAVORBFBProperty);
            }
            set
            {
                SetValue(WAVORBFBProperty, value);
                OnWAVORBFBChg();
            }
        }
        private static void OnWAVORBFBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVORBFB = (string)e.NewValue;
            }
        }
        public virtual void OnWAVORBFBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVORBFB=WAVORBFB;
        }
         #endregion
       #region ==WANACHBFB===========
        public static readonly DependencyProperty WANACHBFBProperty = DependencyProperty.Register("WANACHBFB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWANACHBFBChanged));
        public string WANACHBFB
        {
            get
            {
                return (string)GetValue(WANACHBFBProperty);
            }
            set
            {
                SetValue(WANACHBFBProperty, value);
                OnWANACHBFBChg();
            }
        }
        private static void OnWANACHBFBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WANACHBFB = (string)e.NewValue;
            }
        }
        public virtual void OnWANACHBFBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WANACHBFB=WANACHBFB;
        }
         #endregion
       #region ==WAVORBDR===========
        public static readonly DependencyProperty WAVORBDRProperty = DependencyProperty.Register("WAVORBDR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVORBDRChanged));
        public string WAVORBDR
        {
            get
            {
                return (string)GetValue(WAVORBDRProperty);
            }
            set
            {
                SetValue(WAVORBDRProperty, value);
                OnWAVORBDRChg();
            }
        }
        private static void OnWAVORBDRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVORBDR = (string)e.NewValue;
            }
        }
        public virtual void OnWAVORBDRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVORBDR=WAVORBDR;
        }
         #endregion
       #region ==WANACHBDR===========
        public static readonly DependencyProperty WANACHBDRProperty = DependencyProperty.Register("WANACHBDR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWANACHBDRChanged));
        public string WANACHBDR
        {
            get
            {
                return (string)GetValue(WANACHBDRProperty);
            }
            set
            {
                SetValue(WANACHBDRProperty, value);
                OnWANACHBDRChg();
            }
        }
        private static void OnWANACHBDRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WANACHBDR = (string)e.NewValue;
            }
        }
        public virtual void OnWANACHBDRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WANACHBDR=WANACHBDR;
        }
         #endregion
       #region ==WAVORBAP===========
        public static readonly DependencyProperty WAVORBAPProperty = DependencyProperty.Register("WAVORBAP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVORBAPChanged));
        public string WAVORBAP
        {
            get
            {
                return (string)GetValue(WAVORBAPProperty);
            }
            set
            {
                SetValue(WAVORBAPProperty, value);
                OnWAVORBAPChg();
            }
        }
        private static void OnWAVORBAPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVORBAP = (string)e.NewValue;
            }
        }
        public virtual void OnWAVORBAPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVORBAP=WAVORBAP;
        }
         #endregion
       #region ==WANACHBAP===========
        public static readonly DependencyProperty WANACHBAPProperty = DependencyProperty.Register("WANACHBAP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWANACHBAPChanged));
        public string WANACHBAP
        {
            get
            {
                return (string)GetValue(WANACHBAPProperty);
            }
            set
            {
                SetValue(WANACHBAPProperty, value);
                OnWANACHBAPChg();
            }
        }
        private static void OnWANACHBAPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WANACHBAP = (string)e.NewValue;
            }
        }
        public virtual void OnWANACHBAPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WANACHBAP=WANACHBAP;
        }
         #endregion
       #region ==WAMVB===========
        public static readonly DependencyProperty WAMVBProperty = DependencyProperty.Register("WAMVB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMVBChanged));
        public string WAMVB
        {
            get
            {
                return (string)GetValue(WAMVBProperty);
            }
            set
            {
                SetValue(WAMVBProperty, value);
                OnWAMVBChg();
            }
        }
        private static void OnWAMVBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMVB = (string)e.NewValue;
            }
        }
        public virtual void OnWAMVBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMVB=WAMVB;
        }
         #endregion
       #region ==WAMNB===========
        public static readonly DependencyProperty WAMNBProperty = DependencyProperty.Register("WAMNB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMNBChanged));
        public string WAMNB
        {
            get
            {
                return (string)GetValue(WAMNBProperty);
            }
            set
            {
                SetValue(WAMNBProperty, value);
                OnWAMNBChg();
            }
        }
        private static void OnWAMNBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMNB = (string)e.NewValue;
            }
        }
        public virtual void OnWAMNBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMNB=WAMNB;
        }
         #endregion
       #region ==WACVB===========
        public static readonly DependencyProperty WACVBProperty = DependencyProperty.Register("WACVB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWACVBChanged));
        public string WACVB
        {
            get
            {
                return (string)GetValue(WACVBProperty);
            }
            set
            {
                SetValue(WACVBProperty, value);
                OnWACVBChg();
            }
        }
        private static void OnWACVBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WACVB = (string)e.NewValue;
            }
        }
        public virtual void OnWACVBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WACVB=WACVB;
        }
         #endregion
       #region ==WACNB===========
        public static readonly DependencyProperty WACNBProperty = DependencyProperty.Register("WACNB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWACNBChanged));
        public string WACNB
        {
            get
            {
                return (string)GetValue(WACNBProperty);
            }
            set
            {
                SetValue(WACNBProperty, value);
                OnWACNBChg();
            }
        }
        private static void OnWACNBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WACNB = (string)e.NewValue;
            }
        }
        public virtual void OnWACNBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WACNB=WACNB;
        }
         #endregion
       #region ==WABVB===========
        public static readonly DependencyProperty WABVBProperty = DependencyProperty.Register("WABVB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWABVBChanged));
        public string WABVB
        {
            get
            {
                return (string)GetValue(WABVBProperty);
            }
            set
            {
                SetValue(WABVBProperty, value);
                OnWABVBChg();
            }
        }
        private static void OnWABVBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WABVB = (string)e.NewValue;
            }
        }
        public virtual void OnWABVBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WABVB=WABVB;
        }
         #endregion
       #region ==WABNB===========
        public static readonly DependencyProperty WABNBProperty = DependencyProperty.Register("WABNB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWABNBChanged));
        public string WABNB
        {
            get
            {
                return (string)GetValue(WABNBProperty);
            }
            set
            {
                SetValue(WABNBProperty, value);
                OnWABNBChg();
            }
        }
        private static void OnWABNBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WABNB = (string)e.NewValue;
            }
        }
        public virtual void OnWABNBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WABNB=WABNB;
        }
         #endregion
       #region ==WASVB===========
        public static readonly DependencyProperty WASVBProperty = DependencyProperty.Register("WASVB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASVBChanged));
        public string WASVB
        {
            get
            {
                return (string)GetValue(WASVBProperty);
            }
            set
            {
                SetValue(WASVBProperty, value);
                OnWASVBChg();
            }
        }
        private static void OnWASVBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASVB = (string)e.NewValue;
            }
        }
        public virtual void OnWASVBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASVB=WASVB;
        }
         #endregion
       #region ==WASNB===========
        public static readonly DependencyProperty WASNBProperty = DependencyProperty.Register("WASNB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASNBChanged));
        public string WASNB
        {
            get
            {
                return (string)GetValue(WASNBProperty);
            }
            set
            {
                SetValue(WASNBProperty, value);
                OnWASNBChg();
            }
        }
        private static void OnWASNBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASNB = (string)e.NewValue;
            }
        }
        public virtual void OnWASNBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASNB=WASNB;
        }
         #endregion
       #region ==WASUBSTGR===========
        public static readonly DependencyProperty WASUBSTGRProperty = DependencyProperty.Register("WASUBSTGR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASUBSTGRChanged));
        public string WASUBSTGR
        {
            get
            {
                return (string)GetValue(WASUBSTGRProperty);
            }
            set
            {
                SetValue(WASUBSTGRProperty, value);
                OnWASUBSTGRChg();
            }
        }
        private static void OnWASUBSTGRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASUBSTGR = (string)e.NewValue;
            }
        }
        public virtual void OnWASUBSTGRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASUBSTGR=WASUBSTGR;
        }
         #endregion
       #region ==WAHANDICAP===========
        public static readonly DependencyProperty WAHANDICAPProperty = DependencyProperty.Register("WAHANDICAP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAHANDICAPChanged));
        public string WAHANDICAP
        {
            get
            {
                return (string)GetValue(WAHANDICAPProperty);
            }
            set
            {
                SetValue(WAHANDICAPProperty, value);
                OnWAHANDICAPChg();
            }
        }
        private static void OnWAHANDICAPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAHANDICAP = (string)e.NewValue;
            }
        }
        public virtual void OnWAHANDICAPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAHANDICAP=WAHANDICAP;
        }
         #endregion
       #region ==WAZUSCHAB===========
        public static readonly DependencyProperty WAZUSCHABProperty = DependencyProperty.Register("WAZUSCHAB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAZUSCHABChanged));
        public string WAZUSCHAB
        {
            get
            {
                return (string)GetValue(WAZUSCHABProperty);
            }
            set
            {
                SetValue(WAZUSCHABProperty, value);
                OnWAZUSCHABChg();
            }
        }
        private static void OnWAZUSCHABChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAZUSCHAB = (string)e.NewValue;
            }
        }
        public virtual void OnWAZUSCHABChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAZUSCHAB=WAZUSCHAB;
        }
         #endregion
       #region ==WALOSGRFB===========
        public static readonly DependencyProperty WALOSGRFBProperty = DependencyProperty.Register("WALOSGRFB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWALOSGRFBChanged));
        public string WALOSGRFB
        {
            get
            {
                return (string)GetValue(WALOSGRFBProperty);
            }
            set
            {
                SetValue(WALOSGRFBProperty, value);
                OnWALOSGRFBChg();
            }
        }
        private static void OnWALOSGRFBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WALOSGRFB = (string)e.NewValue;
            }
        }
        public virtual void OnWALOSGRFBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WALOSGRFB=WALOSGRFB;
        }
         #endregion
       #region ==WAQCCHECK===========
        public static readonly DependencyProperty WAQCCHECKProperty = DependencyProperty.Register("WAQCCHECK",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAQCCHECKChanged));
        public string WAQCCHECK
        {
            get
            {
                return (string)GetValue(WAQCCHECKProperty);
            }
            set
            {
                SetValue(WAQCCHECKProperty, value);
                OnWAQCCHECKChg();
            }
        }
        private static void OnWAQCCHECKChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAQCCHECK = (string)e.NewValue;
            }
        }
        public virtual void OnWAQCCHECKChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAQCCHECK=WAQCCHECK;
        }
         #endregion
       #region ==WADART===========
        public static readonly DependencyProperty WADARTProperty = DependencyProperty.Register("WADART",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADARTChanged));
        public string WADART
        {
            get
            {
                return (string)GetValue(WADARTProperty);
            }
            set
            {
                SetValue(WADARTProperty, value);
                OnWADARTChg();
            }
        }
        private static void OnWADARTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADART = (string)e.NewValue;
            }
        }
        public virtual void OnWADARTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADART=WADART;
        }
         #endregion
       #region ==WADVAR===========
        public static readonly DependencyProperty WADVARProperty = DependencyProperty.Register("WADVAR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADVARChanged));
        public string WADVAR
        {
            get
            {
                return (string)GetValue(WADVARProperty);
            }
            set
            {
                SetValue(WADVARProperty, value);
                OnWADVARChg();
            }
        }
        private static void OnWADVARChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADVAR = (string)e.NewValue;
            }
        }
        public virtual void OnWADVARChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADVAR=WADVAR;
        }
         #endregion
       #region ==WADSTDKZ===========
        public static readonly DependencyProperty WADSTDKZProperty = DependencyProperty.Register("WADSTDKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADSTDKZChanged));
        public string WADSTDKZ
        {
            get
            {
                return (string)GetValue(WADSTDKZProperty);
            }
            set
            {
                SetValue(WADSTDKZProperty, value);
                OnWADSTDKZChg();
            }
        }
        private static void OnWADSTDKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADSTDKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWADSTDKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADSTDKZ=WADSTDKZ;
        }
         #endregion
       #region ==WADSACHB===========
        public static readonly DependencyProperty WADSACHBProperty = DependencyProperty.Register("WADSACHB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADSACHBChanged));
        public string WADSACHB
        {
            get
            {
                return (string)GetValue(WADSACHBProperty);
            }
            set
            {
                SetValue(WADSACHBProperty, value);
                OnWADSACHBChg();
            }
        }
        private static void OnWADSACHBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADSACHB = (string)e.NewValue;
            }
        }
        public virtual void OnWADSACHBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADSACHB=WADSACHB;
        }
         #endregion
       #region ==WASCHNKZ===========
        public static readonly DependencyProperty WASCHNKZProperty = DependencyProperty.Register("WASCHNKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASCHNKZChanged));
        public string WASCHNKZ
        {
            get
            {
                return (string)GetValue(WASCHNKZProperty);
            }
            set
            {
                SetValue(WASCHNKZProperty, value);
                OnWASCHNKZChg();
            }
        }
        private static void OnWASCHNKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASCHNKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWASCHNKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASCHNKZ=WASCHNKZ;
        }
         #endregion
       #region ==WAPROGRP===========
        public static readonly DependencyProperty WAPROGRPProperty = DependencyProperty.Register("WAPROGRP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAPROGRPChanged));
        public string WAPROGRP
        {
            get
            {
                return (string)GetValue(WAPROGRPProperty);
            }
            set
            {
                SetValue(WAPROGRPProperty, value);
                OnWAPROGRPChg();
            }
        }
        private static void OnWAPROGRPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAPROGRP = (string)e.NewValue;
            }
        }
        public virtual void OnWAPROGRPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAPROGRP=WAPROGRP;
        }
         #endregion
       #region ==WAARTGRP===========
        public static readonly DependencyProperty WAARTGRPProperty = DependencyProperty.Register("WAARTGRP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAARTGRPChanged));
        public string WAARTGRP
        {
            get
            {
                return (string)GetValue(WAARTGRPProperty);
            }
            set
            {
                SetValue(WAARTGRPProperty, value);
                OnWAARTGRPChg();
            }
        }
        private static void OnWAARTGRPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAARTGRP = (string)e.NewValue;
            }
        }
        public virtual void OnWAARTGRPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAARTGRP=WAARTGRP;
        }
         #endregion
       #region ==WAWBZEIT===========
        public static readonly DependencyProperty WAWBZEITProperty = DependencyProperty.Register("WAWBZEIT",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAWBZEITChanged));
        public string WAWBZEIT
        {
            get
            {
                return (string)GetValue(WAWBZEITProperty);
            }
            set
            {
                SetValue(WAWBZEITProperty, value);
                OnWAWBZEITChg();
            }
        }
        private static void OnWAWBZEITChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAWBZEIT = (string)e.NewValue;
            }
        }
        public virtual void OnWAWBZEITChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAWBZEIT=WAWBZEIT;
        }
         #endregion
       #region ==WAMINBST===========
        public static readonly DependencyProperty WAMINBSTProperty = DependencyProperty.Register("WAMINBST",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMINBSTChanged));
        public string WAMINBST
        {
            get
            {
                return (string)GetValue(WAMINBSTProperty);
            }
            set
            {
                SetValue(WAMINBSTProperty, value);
                OnWAMINBSTChg();
            }
        }
        private static void OnWAMINBSTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMINBST = (string)e.NewValue;
            }
        }
        public virtual void OnWAMINBSTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMINBST=WAMINBST;
        }
         #endregion
       #region ==WAMAXBST===========
        public static readonly DependencyProperty WAMAXBSTProperty = DependencyProperty.Register("WAMAXBST",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMAXBSTChanged));
        public string WAMAXBST
        {
            get
            {
                return (string)GetValue(WAMAXBSTProperty);
            }
            set
            {
                SetValue(WAMAXBSTProperty, value);
                OnWAMAXBSTChg();
            }
        }
        private static void OnWAMAXBSTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMAXBST = (string)e.NewValue;
            }
        }
        public virtual void OnWAMAXBSTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMAXBST=WAMAXBST;
        }
         #endregion
       #region ==WAOPTMGR===========
        public static readonly DependencyProperty WAOPTMGRProperty = DependencyProperty.Register("WAOPTMGR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAOPTMGRChanged));
        public string WAOPTMGR
        {
            get
            {
                return (string)GetValue(WAOPTMGRProperty);
            }
            set
            {
                SetValue(WAOPTMGRProperty, value);
                OnWAOPTMGRChg();
            }
        }
        private static void OnWAOPTMGRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAOPTMGR = (string)e.NewValue;
            }
        }
        public virtual void OnWAOPTMGRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAOPTMGR=WAOPTMGR;
        }
         #endregion
       #region ==WAOPTMGF===========
        public static readonly DependencyProperty WAOPTMGFProperty = DependencyProperty.Register("WAOPTMGF",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAOPTMGFChanged));
        public string WAOPTMGF
        {
            get
            {
                return (string)GetValue(WAOPTMGFProperty);
            }
            set
            {
                SetValue(WAOPTMGFProperty, value);
                OnWAOPTMGFChg();
            }
        }
        private static void OnWAOPTMGFChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAOPTMGF = (string)e.NewValue;
            }
        }
        public virtual void OnWAOPTMGFChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAOPTMGF=WAOPTMGF;
        }
         #endregion
       #region ==WARMINPMENG===========
        public static readonly DependencyProperty WARMINPMENGProperty = DependencyProperty.Register("WARMINPMENG",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARMINPMENGChanged));
        public string WARMINPMENG
        {
            get
            {
                return (string)GetValue(WARMINPMENGProperty);
            }
            set
            {
                SetValue(WARMINPMENGProperty, value);
                OnWARMINPMENGChg();
            }
        }
        private static void OnWARMINPMENGChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARMINPMENG = (string)e.NewValue;
            }
        }
        public virtual void OnWARMINPMENGChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARMINPMENG=WARMINPMENG;
        }
         #endregion
       #region ==WAFMINPMENG===========
        public static readonly DependencyProperty WAFMINPMENGProperty = DependencyProperty.Register("WAFMINPMENG",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFMINPMENGChanged));
        public string WAFMINPMENG
        {
            get
            {
                return (string)GetValue(WAFMINPMENGProperty);
            }
            set
            {
                SetValue(WAFMINPMENGProperty, value);
                OnWAFMINPMENGChg();
            }
        }
        private static void OnWAFMINPMENGChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFMINPMENG = (string)e.NewValue;
            }
        }
        public virtual void OnWAFMINPMENGChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFMINPMENG=WAFMINPMENG;
        }
         #endregion
       #region ==WAUEBM===========
        public static readonly DependencyProperty WAUEBMProperty = DependencyProperty.Register("WAUEBM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAUEBMChanged));
        public string WAUEBM
        {
            get
            {
                return (string)GetValue(WAUEBMProperty);
            }
            set
            {
                SetValue(WAUEBMProperty, value);
                OnWAUEBMChg();
            }
        }
        private static void OnWAUEBMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAUEBM = (string)e.NewValue;
            }
        }
        public virtual void OnWAUEBMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAUEBM=WAUEBM;
        }
         #endregion
       #region ==WAUEBG===========
        public static readonly DependencyProperty WAUEBGProperty = DependencyProperty.Register("WAUEBG",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAUEBGChanged));
        public string WAUEBG
        {
            get
            {
                return (string)GetValue(WAUEBGProperty);
            }
            set
            {
                SetValue(WAUEBGProperty, value);
                OnWAUEBGChg();
            }
        }
        private static void OnWAUEBGChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAUEBG = (string)e.NewValue;
            }
        }
        public virtual void OnWAUEBGChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAUEBG=WAUEBG;
        }
         #endregion
       #region ==WAUEBF===========
        public static readonly DependencyProperty WAUEBFProperty = DependencyProperty.Register("WAUEBF",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAUEBFChanged));
        public string WAUEBF
        {
            get
            {
                return (string)GetValue(WAUEBFProperty);
            }
            set
            {
                SetValue(WAUEBFProperty, value);
                OnWAUEBFChg();
            }
        }
        private static void OnWAUEBFChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAUEBF = (string)e.NewValue;
            }
        }
        public virtual void OnWAUEBFChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAUEBF=WAUEBF;
        }
         #endregion
       #region ==WAMATPRF===========
        public static readonly DependencyProperty WAMATPRFProperty = DependencyProperty.Register("WAMATPRF",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMATPRFChanged));
        public string WAMATPRF
        {
            get
            {
                return (string)GetValue(WAMATPRFProperty);
            }
            set
            {
                SetValue(WAMATPRFProperty, value);
                OnWAMATPRFChg();
            }
        }
        private static void OnWAMATPRFChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMATPRF = (string)e.NewValue;
            }
        }
        public virtual void OnWAMATPRFChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMATPRF=WAMATPRF;
        }
         #endregion
       #region ==WABRTPRF===========
        public static readonly DependencyProperty WABRTPRFProperty = DependencyProperty.Register("WABRTPRF",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWABRTPRFChanged));
        public string WABRTPRF
        {
            get
            {
                return (string)GetValue(WABRTPRFProperty);
            }
            set
            {
                SetValue(WABRTPRFProperty, value);
                OnWABRTPRFChg();
            }
        }
        private static void OnWABRTPRFChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WABRTPRF = (string)e.NewValue;
            }
        }
        public virtual void OnWABRTPRFChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WABRTPRF=WABRTPRF;
        }
         #endregion
       #region ==WAGQMPRF===========
        public static readonly DependencyProperty WAGQMPRFProperty = DependencyProperty.Register("WAGQMPRF",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAGQMPRFChanged));
        public string WAGQMPRF
        {
            get
            {
                return (string)GetValue(WAGQMPRFProperty);
            }
            set
            {
                SetValue(WAGQMPRFProperty, value);
                OnWAGQMPRFChg();
            }
        }
        private static void OnWAGQMPRFChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAGQMPRF = (string)e.NewValue;
            }
        }
        public virtual void OnWAGQMPRFChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAGQMPRF=WAGQMPRF;
        }
         #endregion
       #region ==WASTKGP===========
        public static readonly DependencyProperty WASTKGPProperty = DependencyProperty.Register("WASTKGP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASTKGPChanged));
        public string WASTKGP
        {
            get
            {
                return (string)GetValue(WASTKGPProperty);
            }
            set
            {
                SetValue(WASTKGPProperty, value);
                OnWASTKGPChg();
            }
        }
        private static void OnWASTKGPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASTKGP = (string)e.NewValue;
            }
        }
        public virtual void OnWASTKGPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASTKGP=WASTKGP;
        }
         #endregion
       #region ==WASCHLIP===========
        public static readonly DependencyProperty WASCHLIPProperty = DependencyProperty.Register("WASCHLIP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASCHLIPChanged));
        public string WASCHLIP
        {
            get
            {
                return (string)GetValue(WASCHLIPProperty);
            }
            set
            {
                SetValue(WASCHLIPProperty, value);
                OnWASCHLIPChg();
            }
        }
        private static void OnWASCHLIPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASCHLIP = (string)e.NewValue;
            }
        }
        public virtual void OnWASCHLIPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASCHLIP=WASCHLIP;
        }
         #endregion
       #region ==WASCHLIA===========
        public static readonly DependencyProperty WASCHLIAProperty = DependencyProperty.Register("WASCHLIA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASCHLIAChanged));
        public string WASCHLIA
        {
            get
            {
                return (string)GetValue(WASCHLIAProperty);
            }
            set
            {
                SetValue(WASCHLIAProperty, value);
                OnWASCHLIAChg();
            }
        }
        private static void OnWASCHLIAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASCHLIA = (string)e.NewValue;
            }
        }
        public virtual void OnWASCHLIAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASCHLIA=WASCHLIA;
        }
         #endregion
       #region ==WALPABR===========
        public static readonly DependencyProperty WALPABRProperty = DependencyProperty.Register("WALPABR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWALPABRChanged));
        public string WALPABR
        {
            get
            {
                return (string)GetValue(WALPABRProperty);
            }
            set
            {
                SetValue(WALPABRProperty, value);
                OnWALPABRChg();
            }
        }
        private static void OnWALPABRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WALPABR = (string)e.NewValue;
            }
        }
        public virtual void OnWALPABRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WALPABR=WALPABR;
        }
         #endregion
       #region ==WADISPZS===========
        public static readonly DependencyProperty WADISPZSProperty = DependencyProperty.Register("WADISPZS",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADISPZSChanged));
        public string WADISPZS
        {
            get
            {
                return (string)GetValue(WADISPZSProperty);
            }
            set
            {
                SetValue(WADISPZSProperty, value);
                OnWADISPZSChg();
            }
        }
        private static void OnWADISPZSChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADISPZS = (string)e.NewValue;
            }
        }
        public virtual void OnWADISPZSChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADISPZS=WADISPZS;
        }
         #endregion
       #region ==WADRPAR===========
        public static readonly DependencyProperty WADRPARProperty = DependencyProperty.Register("WADRPAR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWADRPARChanged));
        public string WADRPAR
        {
            get
            {
                return (string)GetValue(WADRPARProperty);
            }
            set
            {
                SetValue(WADRPARProperty, value);
                OnWADRPARChg();
            }
        }
        private static void OnWADRPARChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WADRPAR = (string)e.NewValue;
            }
        }
        public virtual void OnWADRPARChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WADRPAR=WADRPAR;
        }
         #endregion
       #region ==WAZUSTR===========
        public static readonly DependencyProperty WAZUSTRProperty = DependencyProperty.Register("WAZUSTR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAZUSTRChanged));
        public string WAZUSTR
        {
            get
            {
                return (string)GetValue(WAZUSTRProperty);
            }
            set
            {
                SetValue(WAZUSTRProperty, value);
                OnWAZUSTRChg();
            }
        }
        private static void OnWAZUSTRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAZUSTR = (string)e.NewValue;
            }
        }
        public virtual void OnWAZUSTRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAZUSTR=WAZUSTR;
        }
         #endregion
       #region ==WAWDSUM===========
        public static readonly DependencyProperty WAWDSUMProperty = DependencyProperty.Register("WAWDSUM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAWDSUMChanged));
        public string WAWDSUM
        {
            get
            {
                return (string)GetValue(WAWDSUMProperty);
            }
            set
            {
                SetValue(WAWDSUMProperty, value);
                OnWAWDSUMChg();
            }
        }
        private static void OnWAWDSUMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAWDSUM = (string)e.NewValue;
            }
        }
        public virtual void OnWAWDSUMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAWDSUM=WAWDSUM;
        }
         #endregion
       #region ==WASTSKZ===========
        public static readonly DependencyProperty WASTSKZProperty = DependencyProperty.Register("WASTSKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASTSKZChanged));
        public string WASTSKZ
        {
            get
            {
                return (string)GetValue(WASTSKZProperty);
            }
            set
            {
                SetValue(WASTSKZProperty, value);
                OnWASTSKZChg();
            }
        }
        private static void OnWASTSKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASTSKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWASTSKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASTSKZ=WASTSKZ;
        }
         #endregion
       #region ==WASTSART===========
        public static readonly DependencyProperty WASTSARTProperty = DependencyProperty.Register("WASTSART",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASTSARTChanged));
        public string WASTSART
        {
            get
            {
                return (string)GetValue(WASTSARTProperty);
            }
            set
            {
                SetValue(WASTSARTProperty, value);
                OnWASTSARTChg();
            }
        }
        private static void OnWASTSARTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASTSART = (string)e.NewValue;
            }
        }
        public virtual void OnWASTSARTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASTSART=WASTSART;
        }
         #endregion
       #region ==WASTSAUF===========
        public static readonly DependencyProperty WASTSAUFProperty = DependencyProperty.Register("WASTSAUF",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASTSAUFChanged));
        public string WASTSAUF
        {
            get
            {
                return (string)GetValue(WASTSAUFProperty);
            }
            set
            {
                SetValue(WASTSAUFProperty, value);
                OnWASTSAUFChg();
            }
        }
        private static void OnWASTSAUFChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASTSAUF = (string)e.NewValue;
            }
        }
        public virtual void OnWASTSAUFChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASTSAUF=WASTSAUF;
        }
         #endregion
       #region ==WASTSLG===========
        public static readonly DependencyProperty WASTSLGProperty = DependencyProperty.Register("WASTSLG",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASTSLGChanged));
        public string WASTSLG
        {
            get
            {
                return (string)GetValue(WASTSLGProperty);
            }
            set
            {
                SetValue(WASTSLGProperty, value);
                OnWASTSLGChg();
            }
        }
        private static void OnWASTSLGChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASTSLG = (string)e.NewValue;
            }
        }
        public virtual void OnWASTSLGChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASTSLG=WASTSLG;
        }
         #endregion
       #region ==WASTSDKZ===========
        public static readonly DependencyProperty WASTSDKZProperty = DependencyProperty.Register("WASTSDKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASTSDKZChanged));
        public string WASTSDKZ
        {
            get
            {
                return (string)GetValue(WASTSDKZProperty);
            }
            set
            {
                SetValue(WASTSDKZProperty, value);
                OnWASTSDKZChg();
            }
        }
        private static void OnWASTSDKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASTSDKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWASTSDKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASTSDKZ=WASTSDKZ;
        }
         #endregion
       #region ==WAFILLER1===========
        public static readonly DependencyProperty WAFILLER1Property = DependencyProperty.Register("WAFILLER1",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFILLER1Changed));
        public string WAFILLER1
        {
            get
            {
                return (string)GetValue(WAFILLER1Property);
            }
            set
            {
                SetValue(WAFILLER1Property, value);
                OnWAFILLER1Chg();
            }
        }
        private static void OnWAFILLER1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFILLER1 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFILLER1Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFILLER1=WAFILLER1;
        }
         #endregion
       #region ==WAVOLU===========
        public static readonly DependencyProperty WAVOLUProperty = DependencyProperty.Register("WAVOLU",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVOLUChanged));
        public string WAVOLU
        {
            get
            {
                return (string)GetValue(WAVOLUProperty);
            }
            set
            {
                SetValue(WAVOLUProperty, value);
                OnWAVOLUChg();
            }
        }
        private static void OnWAVOLUChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVOLU = (string)e.NewValue;
            }
        }
        public virtual void OnWAVOLUChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVOLU=WAVOLU;
        }
         #endregion
       #region ==WAVOLAM===========
        public static readonly DependencyProperty WAVOLAMProperty = DependencyProperty.Register("WAVOLAM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVOLAMChanged));
        public string WAVOLAM
        {
            get
            {
                return (string)GetValue(WAVOLAMProperty);
            }
            set
            {
                SetValue(WAVOLAMProperty, value);
                OnWAVOLAMChg();
            }
        }
        private static void OnWAVOLAMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVOLAM = (string)e.NewValue;
            }
        }
        public virtual void OnWAVOLAMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVOLAM=WAVOLAM;
        }
         #endregion
       #region ==WAVOLDIAM===========
        public static readonly DependencyProperty WAVOLDIAMProperty = DependencyProperty.Register("WAVOLDIAM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVOLDIAMChanged));
        public string WAVOLDIAM
        {
            get
            {
                return (string)GetValue(WAVOLDIAMProperty);
            }
            set
            {
                SetValue(WAVOLDIAMProperty, value);
                OnWAVOLDIAMChg();
            }
        }
        private static void OnWAVOLDIAMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVOLDIAM = (string)e.NewValue;
            }
        }
        public virtual void OnWAVOLDIAMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVOLDIAM=WAVOLDIAM;
        }
         #endregion
       #region ==WAVOLMTR===========
        public static readonly DependencyProperty WAVOLMTRProperty = DependencyProperty.Register("WAVOLMTR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVOLMTRChanged));
        public string WAVOLMTR
        {
            get
            {
                return (string)GetValue(WAVOLMTRProperty);
            }
            set
            {
                SetValue(WAVOLMTRProperty, value);
                OnWAVOLMTRChg();
            }
        }
        private static void OnWAVOLMTRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVOLMTR = (string)e.NewValue;
            }
        }
        public virtual void OnWAVOLMTRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVOLMTR=WAVOLMTR;
        }
         #endregion
       #region ==WAVOLAMVOL===========
        public static readonly DependencyProperty WAVOLAMVOLProperty = DependencyProperty.Register("WAVOLAMVOL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVOLAMVOLChanged));
        public string WAVOLAMVOL
        {
            get
            {
                return (string)GetValue(WAVOLAMVOLProperty);
            }
            set
            {
                SetValue(WAVOLAMVOLProperty, value);
                OnWAVOLAMVOLChg();
            }
        }
        private static void OnWAVOLAMVOLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVOLAMVOL = (string)e.NewValue;
            }
        }
        public virtual void OnWAVOLAMVOLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVOLAMVOL=WAVOLAMVOL;
        }
         #endregion
       #region ==WAANAB===========
        public static readonly DependencyProperty WAANABProperty = DependencyProperty.Register("WAANAB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAANABChanged));
        public string WAANAB
        {
            get
            {
                return (string)GetValue(WAANABProperty);
            }
            set
            {
                SetValue(WAANABProperty, value);
                OnWAANABChg();
            }
        }
        private static void OnWAANABChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAANAB = (string)e.NewValue;
            }
        }
        public virtual void OnWAANABChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAANAB=WAANAB;
        }
         #endregion
       #region ==WAALBIS===========
        public static readonly DependencyProperty WAALBISProperty = DependencyProperty.Register("WAALBIS",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAALBISChanged));
        public string WAALBIS
        {
            get
            {
                return (string)GetValue(WAALBISProperty);
            }
            set
            {
                SetValue(WAALBISProperty, value);
                OnWAALBISChg();
            }
        }
        private static void OnWAALBISChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAALBIS = (string)e.NewValue;
            }
        }
        public virtual void OnWAALBISChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAALBIS=WAALBIS;
        }
         #endregion
       #region ==WAPLGRP===========
        public static readonly DependencyProperty WAPLGRPProperty = DependencyProperty.Register("WAPLGRP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAPLGRPChanged));
        public string WAPLGRP
        {
            get
            {
                return (string)GetValue(WAPLGRPProperty);
            }
            set
            {
                SetValue(WAPLGRPProperty, value);
                OnWAPLGRPChg();
            }
        }
        private static void OnWAPLGRPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAPLGRP = (string)e.NewValue;
            }
        }
        public virtual void OnWAPLGRPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAPLGRP=WAPLGRP;
        }
         #endregion
       #region ==WAPRODH===========
        public static readonly DependencyProperty WAPRODHProperty = DependencyProperty.Register("WAPRODH",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAPRODHChanged));
        public string WAPRODH
        {
            get
            {
                return (string)GetValue(WAPRODHProperty);
            }
            set
            {
                SetValue(WAPRODHProperty, value);
                OnWAPRODHChg();
            }
        }
        private static void OnWAPRODHChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAPRODH = (string)e.NewValue;
            }
        }
        public virtual void OnWAPRODHChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAPRODH=WAPRODH;
        }
         #endregion
       #region ==WAMATKL===========
        public static readonly DependencyProperty WAMATKLProperty = DependencyProperty.Register("WAMATKL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMATKLChanged));
        public string WAMATKL
        {
            get
            {
                return (string)GetValue(WAMATKLProperty);
            }
            set
            {
                SetValue(WAMATKLProperty, value);
                OnWAMATKLChg();
            }
        }
        private static void OnWAMATKLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMATKL = (string)e.NewValue;
            }
        }
        public virtual void OnWAMATKLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMATKL=WAMATKL;
        }
         #endregion
       #region ==WAPMGRP===========
        public static readonly DependencyProperty WAPMGRPProperty = DependencyProperty.Register("WAPMGRP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAPMGRPChanged));
        public string WAPMGRP
        {
            get
            {
                return (string)GetValue(WAPMGRPProperty);
            }
            set
            {
                SetValue(WAPMGRPProperty, value);
                OnWAPMGRPChg();
            }
        }
        private static void OnWAPMGRPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAPMGRP = (string)e.NewValue;
            }
        }
        public virtual void OnWAPMGRPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAPMGRP=WAPMGRP;
        }
         #endregion
       #region ==WAPRFSCHL===========
        public static readonly DependencyProperty WAPRFSCHLProperty = DependencyProperty.Register("WAPRFSCHL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAPRFSCHLChanged));
        public string WAPRFSCHL
        {
            get
            {
                return (string)GetValue(WAPRFSCHLProperty);
            }
            set
            {
                SetValue(WAPRFSCHLProperty, value);
                OnWAPRFSCHLChg();
            }
        }
        private static void OnWAPRFSCHLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAPRFSCHL = (string)e.NewValue;
            }
        }
        public virtual void OnWAPRFSCHLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAPRFSCHL=WAPRFSCHL;
        }
         #endregion
       #region ==WAKAART===========
        public static readonly DependencyProperty WAKAARTProperty = DependencyProperty.Register("WAKAART",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKAARTChanged));
        public string WAKAART
        {
            get
            {
                return (string)GetValue(WAKAARTProperty);
            }
            set
            {
                SetValue(WAKAARTProperty, value);
                OnWAKAARTChg();
            }
        }
        private static void OnWAKAARTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKAART = (string)e.NewValue;
            }
        }
        public virtual void OnWAKAARTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKAART=WAKAART;
        }
         #endregion
       #region ==WAKAVAR===========
        public static readonly DependencyProperty WAKAVARProperty = DependencyProperty.Register("WAKAVAR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKAVARChanged));
        public string WAKAVAR
        {
            get
            {
                return (string)GetValue(WAKAVARProperty);
            }
            set
            {
                SetValue(WAKAVARProperty, value);
                OnWAKAVARChg();
            }
        }
        private static void OnWAKAVARChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKAVAR = (string)e.NewValue;
            }
        }
        public virtual void OnWAKAVARChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKAVAR=WAKAVAR;
        }
         #endregion
       #region ==WAKASTD===========
        public static readonly DependencyProperty WAKASTDProperty = DependencyProperty.Register("WAKASTD",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKASTDChanged));
        public string WAKASTD
        {
            get
            {
                return (string)GetValue(WAKASTDProperty);
            }
            set
            {
                SetValue(WAKASTDProperty, value);
                OnWAKASTDChg();
            }
        }
        private static void OnWAKASTDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKASTD = (string)e.NewValue;
            }
        }
        public virtual void OnWAKASTDChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKASTD=WAKASTD;
        }
         #endregion
       #region ==WAKAZGRP===========
        public static readonly DependencyProperty WAKAZGRPProperty = DependencyProperty.Register("WAKAZGRP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKAZGRPChanged));
        public string WAKAZGRP
        {
            get
            {
                return (string)GetValue(WAKAZGRPProperty);
            }
            set
            {
                SetValue(WAKAZGRPProperty, value);
                OnWAKAZGRPChg();
            }
        }
        private static void OnWAKAZGRPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKAZGRP = (string)e.NewValue;
            }
        }
        public virtual void OnWAKAZGRPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKAZGRP=WAKAZGRP;
        }
         #endregion
       #region ==WAKAPRGRPN1===========
        public static readonly DependencyProperty WAKAPRGRPN1Property = DependencyProperty.Register("WAKAPRGRPN1",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKAPRGRPN1Changed));
        public string WAKAPRGRPN1
        {
            get
            {
                return (string)GetValue(WAKAPRGRPN1Property);
            }
            set
            {
                SetValue(WAKAPRGRPN1Property, value);
                OnWAKAPRGRPN1Chg();
            }
        }
        private static void OnWAKAPRGRPN1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKAPRGRPN1 = (string)e.NewValue;
            }
        }
        public virtual void OnWAKAPRGRPN1Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKAPRGRPN1=WAKAPRGRPN1;
        }
         #endregion
       #region ==WAKAPRGRPN2===========
        public static readonly DependencyProperty WAKAPRGRPN2Property = DependencyProperty.Register("WAKAPRGRPN2",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKAPRGRPN2Changed));
        public string WAKAPRGRPN2
        {
            get
            {
                return (string)GetValue(WAKAPRGRPN2Property);
            }
            set
            {
                SetValue(WAKAPRGRPN2Property, value);
                OnWAKAPRGRPN2Chg();
            }
        }
        private static void OnWAKAPRGRPN2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKAPRGRPN2 = (string)e.NewValue;
            }
        }
        public virtual void OnWAKAPRGRPN2Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKAPRGRPN2=WAKAPRGRPN2;
        }
         #endregion
       #region ==WAKAPRGRPN3===========
        public static readonly DependencyProperty WAKAPRGRPN3Property = DependencyProperty.Register("WAKAPRGRPN3",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKAPRGRPN3Changed));
        public string WAKAPRGRPN3
        {
            get
            {
                return (string)GetValue(WAKAPRGRPN3Property);
            }
            set
            {
                SetValue(WAKAPRGRPN3Property, value);
                OnWAKAPRGRPN3Chg();
            }
        }
        private static void OnWAKAPRGRPN3Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKAPRGRPN3 = (string)e.NewValue;
            }
        }
        public virtual void OnWAKAPRGRPN3Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKAPRGRPN3=WAKAPRGRPN3;
        }
         #endregion
       #region ==WAKAAGRA===========
        public static readonly DependencyProperty WAKAAGRAProperty = DependencyProperty.Register("WAKAAGRA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKAAGRAChanged));
        public string WAKAAGRA
        {
            get
            {
                return (string)GetValue(WAKAAGRAProperty);
            }
            set
            {
                SetValue(WAKAAGRAProperty, value);
                OnWAKAAGRAChg();
            }
        }
        private static void OnWAKAAGRAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKAAGRA = (string)e.NewValue;
            }
        }
        public virtual void OnWAKAAGRAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKAAGRA=WAKAAGRA;
        }
         #endregion
       #region ==WAKAAGRP===========
        public static readonly DependencyProperty WAKAAGRPProperty = DependencyProperty.Register("WAKAAGRP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKAAGRPChanged));
        public string WAKAAGRP
        {
            get
            {
                return (string)GetValue(WAKAAGRPProperty);
            }
            set
            {
                SetValue(WAKAAGRPProperty, value);
                OnWAKAAGRPChg();
            }
        }
        private static void OnWAKAAGRPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKAAGRP = (string)e.NewValue;
            }
        }
        public virtual void OnWAKAAGRPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKAAGRP=WAKAAGRP;
        }
         #endregion
       #region ==WAZWTWAHL===========
        public static readonly DependencyProperty WAZWTWAHLProperty = DependencyProperty.Register("WAZWTWAHL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAZWTWAHLChanged));
        public string WAZWTWAHL
        {
            get
            {
                return (string)GetValue(WAZWTWAHLProperty);
            }
            set
            {
                SetValue(WAZWTWAHLProperty, value);
                OnWAZWTWAHLChg();
            }
        }
        private static void OnWAZWTWAHLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAZWTWAHL = (string)e.NewValue;
            }
        }
        public virtual void OnWAZWTWAHLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAZWTWAHL=WAZWTWAHL;
        }
         #endregion
       #region ==WAVERL===========
        public static readonly DependencyProperty WAVERLProperty = DependencyProperty.Register("WAVERL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVERLChanged));
        public string WAVERL
        {
            get
            {
                return (string)GetValue(WAVERLProperty);
            }
            set
            {
                SetValue(WAVERLProperty, value);
                OnWAVERLChg();
            }
        }
        private static void OnWAVERLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVERL = (string)e.NewValue;
            }
        }
        public virtual void OnWAVERLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVERL=WAVERL;
        }
         #endregion
       #region ==WAABR===========
        public static readonly DependencyProperty WAABRProperty = DependencyProperty.Register("WAABR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAABRChanged));
        public string WAABR
        {
            get
            {
                return (string)GetValue(WAABRProperty);
            }
            set
            {
                SetValue(WAABRProperty, value);
                OnWAABRChg();
            }
        }
        private static void OnWAABRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAABR = (string)e.NewValue;
            }
        }
        public virtual void OnWAABRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAABR=WAABR;
        }
         #endregion
       #region ==WAABRTOL===========
        public static readonly DependencyProperty WAABRTOLProperty = DependencyProperty.Register("WAABRTOL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAABRTOLChanged));
        public string WAABRTOL
        {
            get
            {
                return (string)GetValue(WAABRTOLProperty);
            }
            set
            {
                SetValue(WAABRTOLProperty, value);
                OnWAABRTOLChg();
            }
        }
        private static void OnWAABRTOLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAABRTOL = (string)e.NewValue;
            }
        }
        public virtual void OnWAABRTOLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAABRTOL=WAABRTOL;
        }
         #endregion
       #region ==WAKABRT===========
        public static readonly DependencyProperty WAKABRTProperty = DependencyProperty.Register("WAKABRT",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKABRTChanged));
        public string WAKABRT
        {
            get
            {
                return (string)GetValue(WAKABRTProperty);
            }
            set
            {
                SetValue(WAKABRTProperty, value);
                OnWAKABRTChg();
            }
        }
        private static void OnWAKABRTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKABRT = (string)e.NewValue;
            }
        }
        public virtual void OnWAKABRTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKABRT=WAKABRT;
        }
         #endregion
       #region ==WARKABRTOL===========
        public static readonly DependencyProperty WARKABRTOLProperty = DependencyProperty.Register("WARKABRTOL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARKABRTOLChanged));
        public string WARKABRTOL
        {
            get
            {
                return (string)GetValue(WARKABRTOLProperty);
            }
            set
            {
                SetValue(WARKABRTOLProperty, value);
                OnWARKABRTOLChg();
            }
        }
        private static void OnWARKABRTOLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARKABRTOL = (string)e.NewValue;
            }
        }
        public virtual void OnWARKABRTOLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARKABRTOL=WARKABRTOL;
        }
         #endregion
       #region ==WAFKABRTOL===========
        public static readonly DependencyProperty WAFKABRTOLProperty = DependencyProperty.Register("WAFKABRTOL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFKABRTOLChanged));
        public string WAFKABRTOL
        {
            get
            {
                return (string)GetValue(WAFKABRTOLProperty);
            }
            set
            {
                SetValue(WAFKABRTOLProperty, value);
                OnWAFKABRTOLChg();
            }
        }
        private static void OnWAFKABRTOLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFKABRTOL = (string)e.NewValue;
            }
        }
        public virtual void OnWAFKABRTOLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFKABRTOL=WAFKABRTOL;
        }
         #endregion
       #region ==WAMATKTO===========
        public static readonly DependencyProperty WAMATKTOProperty = DependencyProperty.Register("WAMATKTO",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMATKTOChanged));
        public string WAMATKTO
        {
            get
            {
                return (string)GetValue(WAMATKTOProperty);
            }
            set
            {
                SetValue(WAMATKTOProperty, value);
                OnWAMATKTOChg();
            }
        }
        private static void OnWAMATKTOChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMATKTO = (string)e.NewValue;
            }
        }
        public virtual void OnWAMATKTOChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMATKTO=WAMATKTO;
        }
         #endregion
       #region ==WAKTO1===========
        public static readonly DependencyProperty WAKTO1Property = DependencyProperty.Register("WAKTO1",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKTO1Changed));
        public string WAKTO1
        {
            get
            {
                return (string)GetValue(WAKTO1Property);
            }
            set
            {
                SetValue(WAKTO1Property, value);
                OnWAKTO1Chg();
            }
        }
        private static void OnWAKTO1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKTO1 = (string)e.NewValue;
            }
        }
        public virtual void OnWAKTO1Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKTO1=WAKTO1;
        }
         #endregion
       #region ==WAGV===========
        public static readonly DependencyProperty WAGVProperty = DependencyProperty.Register("WAGV",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAGVChanged));
        public string WAGV
        {
            get
            {
                return (string)GetValue(WAGVProperty);
            }
            set
            {
                SetValue(WAGVProperty, value);
                OnWAGVChg();
            }
        }
        private static void OnWAGVChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAGV = (string)e.NewValue;
            }
        }
        public virtual void OnWAGVChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAGV=WAGV;
        }
         #endregion
       #region ==WAKBON===========
        public static readonly DependencyProperty WAKBONProperty = DependencyProperty.Register("WAKBON",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKBONChanged));
        public string WAKBON
        {
            get
            {
                return (string)GetValue(WAKBONProperty);
            }
            set
            {
                SetValue(WAKBONProperty, value);
                OnWAKBONChg();
            }
        }
        private static void OnWAKBONChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKBON = (string)e.NewValue;
            }
        }
        public virtual void OnWAKBONChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKBON=WAKBON;
        }
         #endregion
       #region ==WAMGKMM===========
        public static readonly DependencyProperty WAMGKMMProperty = DependencyProperty.Register("WAMGKMM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMGKMMChanged));
        public string WAMGKMM
        {
            get
            {
                return (string)GetValue(WAMGKMMProperty);
            }
            set
            {
                SetValue(WAMGKMMProperty, value);
                OnWAMGKMMChg();
            }
        }
        private static void OnWAMGKMMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMGKMM = (string)e.NewValue;
            }
        }
        public virtual void OnWAMGKMMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMGKMM=WAMGKMM;
        }
         #endregion
       #region ==WAMEZ===========
        public static readonly DependencyProperty WAMEZProperty = DependencyProperty.Register("WAMEZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMEZChanged));
        public string WAMEZ
        {
            get
            {
                return (string)GetValue(WAMEZProperty);
            }
            set
            {
                SetValue(WAMEZProperty, value);
                OnWAMEZChg();
            }
        }
        private static void OnWAMEZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMEZ = (string)e.NewValue;
            }
        }
        public virtual void OnWAMEZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMEZ=WAMEZ;
        }
         #endregion
       #region ==WAWAG===========
        public static readonly DependencyProperty WAWAGProperty = DependencyProperty.Register("WAWAG",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAWAGChanged));
        public string WAWAG
        {
            get
            {
                return (string)GetValue(WAWAGProperty);
            }
            set
            {
                SetValue(WAWAGProperty, value);
                OnWAWAGChg();
            }
        }
        private static void OnWAWAGChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAWAG = (string)e.NewValue;
            }
        }
        public virtual void OnWAWAGChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAWAG=WAWAG;
        }
         #endregion
       #region ==WABKLAS===========
        public static readonly DependencyProperty WABKLASProperty = DependencyProperty.Register("WABKLAS",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWABKLASChanged));
        public string WABKLAS
        {
            get
            {
                return (string)GetValue(WABKLASProperty);
            }
            set
            {
                SetValue(WABKLASProperty, value);
                OnWABKLASChg();
            }
        }
        private static void OnWABKLASChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WABKLAS = (string)e.NewValue;
            }
        }
        public virtual void OnWABKLASChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WABKLAS=WABKLAS;
        }
         #endregion
       #region ==WABWPLAN===========
        public static readonly DependencyProperty WABWPLANProperty = DependencyProperty.Register("WABWPLAN",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWABWPLANChanged));
        public string WABWPLAN
        {
            get
            {
                return (string)GetValue(WABWPLANProperty);
            }
            set
            {
                SetValue(WABWPLANProperty, value);
                OnWABWPLANChg();
            }
        }
        private static void OnWABWPLANChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WABWPLAN = (string)e.NewValue;
            }
        }
        public virtual void OnWABWPLANChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WABWPLAN=WABWPLAN;
        }
         #endregion
       #region ==WAEKGRP===========
        public static readonly DependencyProperty WAEKGRPProperty = DependencyProperty.Register("WAEKGRP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAEKGRPChanged));
        public string WAEKGRP
        {
            get
            {
                return (string)GetValue(WAEKGRPProperty);
            }
            set
            {
                SetValue(WAEKGRPProperty, value);
                OnWAEKGRPChg();
            }
        }
        private static void OnWAEKGRPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAEKGRP = (string)e.NewValue;
            }
        }
        public virtual void OnWAEKGRPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAEKGRP=WAEKGRP;
        }
         #endregion
       #region ==WABSTME===========
        public static readonly DependencyProperty WABSTMEProperty = DependencyProperty.Register("WABSTME",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWABSTMEChanged));
        public string WABSTME
        {
            get
            {
                return (string)GetValue(WABSTMEProperty);
            }
            set
            {
                SetValue(WABSTMEProperty, value);
                OnWABSTMEChg();
            }
        }
        private static void OnWABSTMEChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WABSTME = (string)e.NewValue;
            }
        }
        public virtual void OnWABSTMEChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WABSTME=WABSTME;
        }
         #endregion
       #region ==WAVABME===========
        public static readonly DependencyProperty WAVABMEProperty = DependencyProperty.Register("WAVABME",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAVABMEChanged));
        public string WAVABME
        {
            get
            {
                return (string)GetValue(WAVABMEProperty);
            }
            set
            {
                SetValue(WAVABMEProperty, value);
                OnWAVABMEChg();
            }
        }
        private static void OnWAVABMEChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAVABME = (string)e.NewValue;
            }
        }
        public virtual void OnWAVABMEChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAVABME=WAVABME;
        }
         #endregion
       #region ==WAEKWSL===========
        public static readonly DependencyProperty WAEKWSLProperty = DependencyProperty.Register("WAEKWSL",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAEKWSLChanged));
        public string WAEKWSL
        {
            get
            {
                return (string)GetValue(WAEKWSLProperty);
            }
            set
            {
                SetValue(WAEKWSLProperty, value);
                OnWAEKWSLChg();
            }
        }
        private static void OnWAEKWSLChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAEKWSL = (string)e.NewValue;
            }
        }
        public virtual void OnWAEKWSLChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAEKWSL=WAEKWSL;
        }
         #endregion
       #region ==WALIEFNR===========
        public static readonly DependencyProperty WALIEFNRProperty = DependencyProperty.Register("WALIEFNR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWALIEFNRChanged));
        public string WALIEFNR
        {
            get
            {
                return (string)GetValue(WALIEFNRProperty);
            }
            set
            {
                SetValue(WALIEFNRProperty, value);
                OnWALIEFNRChg();
            }
        }
        private static void OnWALIEFNRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WALIEFNR = (string)e.NewValue;
            }
        }
        public virtual void OnWALIEFNRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WALIEFNR=WALIEFNR;
        }
         #endregion
       #region ==WAEG===========
        public static readonly DependencyProperty WAEGProperty = DependencyProperty.Register("WAEG",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAEGChanged));
        public string WAEG
        {
            get
            {
                return (string)GetValue(WAEGProperty);
            }
            set
            {
                SetValue(WAEGProperty, value);
                OnWAEGChg();
            }
        }
        private static void OnWAEGChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAEG = (string)e.NewValue;
            }
        }
        public virtual void OnWAEGChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAEG=WAEG;
        }
         #endregion
       #region ==WABON===========
        public static readonly DependencyProperty WABONProperty = DependencyProperty.Register("WABON",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWABONChanged));
        public string WABON
        {
            get
            {
                return (string)GetValue(WABONProperty);
            }
            set
            {
                SetValue(WABONProperty, value);
                OnWABONChg();
            }
        }
        private static void OnWABONChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WABON = (string)e.NewValue;
            }
        }
        public virtual void OnWABONChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WABON=WABON;
        }
         #endregion
       #region ==WAKUNDE===========
        public static readonly DependencyProperty WAKUNDEProperty = DependencyProperty.Register("WAKUNDE",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKUNDEChanged));
        public string WAKUNDE
        {
            get
            {
                return (string)GetValue(WAKUNDEProperty);
            }
            set
            {
                SetValue(WAKUNDEProperty, value);
                OnWAKUNDEChg();
            }
        }
        private static void OnWAKUNDEChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKUNDE = (string)e.NewValue;
            }
        }
        public virtual void OnWAKUNDEChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKUNDE=WAKUNDE;
        }
         #endregion
       #region ==WALOHNW===========
        public static readonly DependencyProperty WALOHNWProperty = DependencyProperty.Register("WALOHNW",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWALOHNWChanged));
        public string WALOHNW
        {
            get
            {
                return (string)GetValue(WALOHNWProperty);
            }
            set
            {
                SetValue(WALOHNWProperty, value);
                OnWALOHNWChg();
            }
        }
        private static void OnWALOHNWChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WALOHNW = (string)e.NewValue;
            }
        }
        public virtual void OnWALOHNWChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WALOHNW=WALOHNW;
        }
         #endregion
       #region ==WALOHNA===========
        public static readonly DependencyProperty WALOHNAProperty = DependencyProperty.Register("WALOHNA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWALOHNAChanged));
        public string WALOHNA
        {
            get
            {
                return (string)GetValue(WALOHNAProperty);
            }
            set
            {
                SetValue(WALOHNAProperty, value);
                OnWALOHNAChg();
            }
        }
        private static void OnWALOHNAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WALOHNA = (string)e.NewValue;
            }
        }
        public virtual void OnWALOHNAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WALOHNA=WALOHNA;
        }
         #endregion
       #region ==WASCHLIAUF===========
        public static readonly DependencyProperty WASCHLIAUFProperty = DependencyProperty.Register("WASCHLIAUF",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWASCHLIAUFChanged));
        public string WASCHLIAUF
        {
            get
            {
                return (string)GetValue(WASCHLIAUFProperty);
            }
            set
            {
                SetValue(WASCHLIAUFProperty, value);
                OnWASCHLIAUFChg();
            }
        }
        private static void OnWASCHLIAUFChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WASCHLIAUF = (string)e.NewValue;
            }
        }
        public virtual void OnWASCHLIAUFChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WASCHLIAUF=WASCHLIAUF;
        }
         #endregion
       #region ==WAPFCODE===========
        public static readonly DependencyProperty WAPFCODEProperty = DependencyProperty.Register("WAPFCODE",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAPFCODEChanged));
        public string WAPFCODE
        {
            get
            {
                return (string)GetValue(WAPFCODEProperty);
            }
            set
            {
                SetValue(WAPFCODEProperty, value);
                OnWAPFCODEChg();
            }
        }
        private static void OnWAPFCODEChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAPFCODE = (string)e.NewValue;
            }
        }
        public virtual void OnWAPFCODEChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAPFCODE=WAPFCODE;
        }
         #endregion
       #region ==WAAUFKZ===========
        public static readonly DependencyProperty WAAUFKZProperty = DependencyProperty.Register("WAAUFKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAAUFKZChanged));
        public string WAAUFKZ
        {
            get
            {
                return (string)GetValue(WAAUFKZProperty);
            }
            set
            {
                SetValue(WAAUFKZProperty, value);
                OnWAAUFKZChg();
            }
        }
        private static void OnWAAUFKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAAUFKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWAAUFKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAAUFKZ=WAAUFKZ;
        }
         #endregion
       #region ==WAMRKM1===========
        public static readonly DependencyProperty WAMRKM1Property = DependencyProperty.Register("WAMRKM1",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMRKM1Changed));
        public string WAMRKM1
        {
            get
            {
                return (string)GetValue(WAMRKM1Property);
            }
            set
            {
                SetValue(WAMRKM1Property, value);
                OnWAMRKM1Chg();
            }
        }
        private static void OnWAMRKM1Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMRKM1 = (string)e.NewValue;
            }
        }
        public virtual void OnWAMRKM1Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMRKM1=WAMRKM1;
        }
         #endregion
       #region ==WAMRKM2===========
        public static readonly DependencyProperty WAMRKM2Property = DependencyProperty.Register("WAMRKM2",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMRKM2Changed));
        public string WAMRKM2
        {
            get
            {
                return (string)GetValue(WAMRKM2Property);
            }
            set
            {
                SetValue(WAMRKM2Property, value);
                OnWAMRKM2Chg();
            }
        }
        private static void OnWAMRKM2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMRKM2 = (string)e.NewValue;
            }
        }
        public virtual void OnWAMRKM2Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMRKM2=WAMRKM2;
        }
         #endregion
       #region ==WAMRKM3===========
        public static readonly DependencyProperty WAMRKM3Property = DependencyProperty.Register("WAMRKM3",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMRKM3Changed));
        public string WAMRKM3
        {
            get
            {
                return (string)GetValue(WAMRKM3Property);
            }
            set
            {
                SetValue(WAMRKM3Property, value);
                OnWAMRKM3Chg();
            }
        }
        private static void OnWAMRKM3Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMRKM3 = (string)e.NewValue;
            }
        }
        public virtual void OnWAMRKM3Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMRKM3=WAMRKM3;
        }
         #endregion
       #region ==WAMRKM4===========
        public static readonly DependencyProperty WAMRKM4Property = DependencyProperty.Register("WAMRKM4",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMRKM4Changed));
        public string WAMRKM4
        {
            get
            {
                return (string)GetValue(WAMRKM4Property);
            }
            set
            {
                SetValue(WAMRKM4Property, value);
                OnWAMRKM4Chg();
            }
        }
        private static void OnWAMRKM4Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMRKM4 = (string)e.NewValue;
            }
        }
        public virtual void OnWAMRKM4Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMRKM4=WAMRKM4;
        }
         #endregion
       #region ==WAMRKM5===========
        public static readonly DependencyProperty WAMRKM5Property = DependencyProperty.Register("WAMRKM5",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAMRKM5Changed));
        public string WAMRKM5
        {
            get
            {
                return (string)GetValue(WAMRKM5Property);
            }
            set
            {
                SetValue(WAMRKM5Property, value);
                OnWAMRKM5Chg();
            }
        }
        private static void OnWAMRKM5Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAMRKM5 = (string)e.NewValue;
            }
        }
        public virtual void OnWAMRKM5Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAMRKM5=WAMRKM5;
        }
         #endregion
       #region ==WAESACHB===========
        public static readonly DependencyProperty WAESACHBProperty = DependencyProperty.Register("WAESACHB",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAESACHBChanged));
        public string WAESACHB
        {
            get
            {
                return (string)GetValue(WAESACHBProperty);
            }
            set
            {
                SetValue(WAESACHBProperty, value);
                OnWAESACHBChg();
            }
        }
        private static void OnWAESACHBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAESACHB = (string)e.NewValue;
            }
        }
        public virtual void OnWAESACHBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAESACHB=WAESACHB;
        }
         #endregion
       #region ==WAESACHBKZ===========
        public static readonly DependencyProperty WAESACHBKZProperty = DependencyProperty.Register("WAESACHBKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAESACHBKZChanged));
        public string WAESACHBKZ
        {
            get
            {
                return (string)GetValue(WAESACHBKZProperty);
            }
            set
            {
                SetValue(WAESACHBKZProperty, value);
                OnWAESACHBKZChg();
            }
        }
        private static void OnWAESACHBKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAESACHBKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWAESACHBKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAESACHBKZ=WAESACHBKZ;
        }
         #endregion
       #region ==WAFBGRLFM===========
        public static readonly DependencyProperty WAFBGRLFMProperty = DependencyProperty.Register("WAFBGRLFM",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFBGRLFMChanged));
        public string WAFBGRLFM
        {
            get
            {
                return (string)GetValue(WAFBGRLFMProperty);
            }
            set
            {
                SetValue(WAFBGRLFMProperty, value);
                OnWAFBGRLFMChg();
            }
        }
        private static void OnWAFBGRLFMChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFBGRLFM = (string)e.NewValue;
            }
        }
        public virtual void OnWAFBGRLFMChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFBGRLFM=WAFBGRLFM;
        }
         #endregion
       #region ==WAPRUEFKZ===========
        public static readonly DependencyProperty WAPRUEFKZProperty = DependencyProperty.Register("WAPRUEFKZ",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAPRUEFKZChanged));
        public string WAPRUEFKZ
        {
            get
            {
                return (string)GetValue(WAPRUEFKZProperty);
            }
            set
            {
                SetValue(WAPRUEFKZProperty, value);
                OnWAPRUEFKZChg();
            }
        }
        private static void OnWAPRUEFKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAPRUEFKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWAPRUEFKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAPRUEFKZ=WAPRUEFKZ;
        }
         #endregion
       #region ==WAPRUEFBEN===========
        public static readonly DependencyProperty WAPRUEFBENProperty = DependencyProperty.Register("WAPRUEFBEN",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAPRUEFBENChanged));
        public string WAPRUEFBEN
        {
            get
            {
                return (string)GetValue(WAPRUEFBENProperty);
            }
            set
            {
                SetValue(WAPRUEFBENProperty, value);
                OnWAPRUEFBENChg();
            }
        }
        private static void OnWAPRUEFBENChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAPRUEFBEN = (string)e.NewValue;
            }
        }
        public virtual void OnWAPRUEFBENChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAPRUEFBEN=WAPRUEFBEN;
        }
         #endregion
       #region ==WAPRUEFDAT===========
        public static readonly DependencyProperty WAPRUEFDATProperty = DependencyProperty.Register("WAPRUEFDAT",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAPRUEFDATChanged));
        public string WAPRUEFDAT
        {
            get
            {
                return (string)GetValue(WAPRUEFDATProperty);
            }
            set
            {
                SetValue(WAPRUEFDATProperty, value);
                OnWAPRUEFDATChg();
            }
        }
        private static void OnWAPRUEFDATChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAPRUEFDAT = (string)e.NewValue;
            }
        }
        public virtual void OnWAPRUEFDATChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAPRUEFDAT=WAPRUEFDAT;
        }
         #endregion
       #region ==WARAVGRP===========
        public static readonly DependencyProperty WARAVGRPProperty = DependencyProperty.Register("WARAVGRP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWARAVGRPChanged));
        public string WARAVGRP
        {
            get
            {
                return (string)GetValue(WARAVGRPProperty);
            }
            set
            {
                SetValue(WARAVGRPProperty, value);
                OnWARAVGRPChg();
            }
        }
        private static void OnWARAVGRPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WARAVGRP = (string)e.NewValue;
            }
        }
        public virtual void OnWARAVGRPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WARAVGRP=WARAVGRP;
        }
         #endregion
       #region ==WATAX===========
        public static readonly DependencyProperty WATAXProperty = DependencyProperty.Register("WATAX",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWATAXChanged));
        public string WATAX
        {
            get
            {
                return (string)GetValue(WATAXProperty);
            }
            set
            {
                SetValue(WATAXProperty, value);
                OnWATAXChg();
            }
        }
        private static void OnWATAXChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WATAX = (string)e.NewValue;
            }
        }
        public virtual void OnWATAXChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WATAX=WATAX;
        }
         #endregion
       #region ==WAPARTBA===========
        public static readonly DependencyProperty WAPARTBAProperty = DependencyProperty.Register("WAPARTBA",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAPARTBAChanged));
        public string WAPARTBA
        {
            get
            {
                return (string)GetValue(WAPARTBAProperty);
            }
            set
            {
                SetValue(WAPARTBAProperty, value);
                OnWAPARTBAChg();
            }
        }
        private static void OnWAPARTBAChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAPARTBA = (string)e.NewValue;
            }
        }
        public virtual void OnWAPARTBAChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAPARTBA=WAPARTBA;
        }
         #endregion
       #region ==WAFDDIF===========
        public static readonly DependencyProperty WAFDDIFProperty = DependencyProperty.Register("WAFDDIF",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFDDIFChanged));
        public string WAFDDIF
        {
            get
            {
                return (string)GetValue(WAFDDIFProperty);
            }
            set
            {
                SetValue(WAFDDIFProperty, value);
                OnWAFDDIFChg();
            }
        }
        private static void OnWAFDDIFChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFDDIF = (string)e.NewValue;
            }
        }
        public virtual void OnWAFDDIFChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFDDIF=WAFDDIF;
        }
         #endregion
       #region ==WAINSPCOR===========
        public static readonly DependencyProperty WAINSPCORProperty = DependencyProperty.Register("WAINSPCOR",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAINSPCORChanged));
        public string WAINSPCOR
        {
            get
            {
                return (string)GetValue(WAINSPCORProperty);
            }
            set
            {
                SetValue(WAINSPCORProperty, value);
                OnWAINSPCORChg();
            }
        }
        private static void OnWAINSPCORChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAINSPCOR = (string)e.NewValue;
            }
        }
        public virtual void OnWAINSPCORChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAINSPCOR=WAINSPCOR;
        }
         #endregion
       #region ==WAINSPGRP===========
        public static readonly DependencyProperty WAINSPGRPProperty = DependencyProperty.Register("WAINSPGRP",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAINSPGRPChanged));
        public string WAINSPGRP
        {
            get
            {
                return (string)GetValue(WAINSPGRPProperty);
            }
            set
            {
                SetValue(WAINSPGRPProperty, value);
                OnWAINSPGRPChg();
            }
        }
        private static void OnWAINSPGRPChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAINSPGRP = (string)e.NewValue;
            }
        }
        public virtual void OnWAINSPGRPChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAINSPGRP=WAINSPGRP;
        }
         #endregion
       #region ==WAKENNFD===========
        public static readonly DependencyProperty WAKENNFDProperty = DependencyProperty.Register("WAKENNFD",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKENNFDChanged));
        public string WAKENNFD
        {
            get
            {
                return (string)GetValue(WAKENNFDProperty);
            }
            set
            {
                SetValue(WAKENNFDProperty, value);
                OnWAKENNFDChg();
            }
        }
        private static void OnWAKENNFDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAKENNFD = (string)e.NewValue;
            }
        }
        public virtual void OnWAKENNFDChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKENNFD=WAKENNFD;
        }
         #endregion
       #region ==WAFILLER2===========
        public static readonly DependencyProperty WAFILLER2Property = DependencyProperty.Register("WAFILLER2",
            typeof(string), typeof(UIWASTAMM),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAFILLER2Changed));
        public string WAFILLER2
        {
            get
            {
                return (string)GetValue(WAFILLER2Property);
            }
            set
            {
                SetValue(WAFILLER2Property, value);
                OnWAFILLER2Chg();
            }
        }
        private static void OnWAFILLER2Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIWASTAMM;
            if (src != null)
            {
                src.WAFILLER2 = (string)e.NewValue;
            }
        }
        public virtual void OnWAFILLER2Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAFILLER2=WAFILLER2;
        }
         #endregion
       */
       
       #endregion
    } 
}
